shouldThrow

SwipeRefreshLayout

/*
    Fetching data from Firebase and
    passing the value to Adapter
    */
val addValueEventListener = firebaseReference.addValueEventListener(object : ValueEventListener {
    override fun onCancelled(p0: DatabaseError) {
        TODO("not implemented") //To change body of created functions use File | Settings | File Templates.
    }

    override fun onDataChange(p0: DataSnapshot) {
        if (p0!!.exists()) {
            val vibeList = mutableListOf<Vibes>()
            // V stands for Vibe
            for (v in p0.children) {
                val vibe = v.getValue(Vibes::class.java)
                vibeList.add(vibe!!)
            }
            recyclerView.adapter = VibeAdapter(vibeList)
        }
    }

})


/*
    Fetch data from Firebase and
    passing the value to Adapter whenever
    swipe refresh triggered
    */
swipeRefreshLayout.setOnRefreshListener {
    val addValueEventListener = firebaseReference.addValueEventListener(object : ValueEventListener {
        override fun onCancelled(p0: DatabaseError) {
            TODO("not implemented") //To change body of created functions use File | Settings | File Templates.
        }

        override fun onDataChange(p0: DataSnapshot) {
            if (p0!!.exists()) {
                val vibeList = mutableListOf<Vibes>()
                // V stands for Vibe
                for (v in p0.children) {
                    val vibe = v.getValue(Vibes::class.java)
                    vibeList.add(vibe!!)
                }
                recyclerView.adapter = VibeAdapter(vibeList)
            }
        }

    })
}

var resultValidator = testExecutor.whenever(wheneverCommand!!)
        resultValidator = expects.events?.let { resultValidator.expectEvents(*it.toTypedArray()) } ?: resultValidator
        resultValidator = expects.eventsMatching?.let { resultValidator.expectEventsMatching(it) } ?: resultValidator
        resultValidator = expects.returnValue?.let { resultValidator.expectReturnValue(it) } ?: resultValidator
        resultValidator = expects.returnValueMatching?.let { resultValidator.expectReturnValueMatching(it) } ?: resultValidator

"INVALID REQUEST"                     -> html("The PayPal API failed us. INVALID_REQUEST")
      "AUTHENTICATION_FAILURE"              -> html("I'm sure we authenticated. Right, guys? AUTHENTICATION_FAILURE")
      "NOT_AUTHORIZED"                      -> html("What do you mean we are not authorized? >:( NOT_AUTHORIZED")
      "RESOURCE_NOT_FOUND"                  -> html("Guys, we need to update our API. RESOURCE_NOT_FOUND")
      "METHOD_NOT_SUPPORTED"                -> html("This wasn't suppose to happen... METHOD_NOT_SUPPORTED")
      "MEDIA_TYPE_NOT_ACCEPTABLE"           -> html("This wasn't suppose to happen... MEDIA_TYPE_NOT_ACCEPTABLE")
      "UNPROCESSABLE_ENTITY"                -> html("Guys, we broke PayPal! UNPROCESSABLE_ENTITY")
      "RATE_LIMIT_REACHED"                  -> html("We've reached max capacity. Please try again later. RATE_LIMIT_REACHED")
      "INTERNAL_SERVICE_ERROR"              -> html("Look. PayPal. You need to fix your system. INTERNAL_SERVICE_ERROR")
      "SERVICE_UNAVAILABLE"                 -> html("PayPal is not available at the moment. Please try again later. SERVICE_UNAVAILABLE")

for

fun primeFactorsOf(integer: Int): List<Int> {
	val primeFactors = mutableListOf<Int>()
	var n = integer
	var divisor = 2
	while (n > 1) {
		while (n % divisor == 0) {
			primeFactors.add(divisor)
			n /= divisor
		}
		divisor++
	}
	return primeFactors
}

public static List<Integer> primeFactorsOf(int integer) {
	List<Integer> primeFactors = new ArrayList<>();
	for (int divisor = 2; integer > 1; divisor++)
		for (; integer % divisor == 0; integer /= divisor)
			primeFactors.add(divisor);
	return primeFactors;
}

delayer

argumentCaptor<() -> Unit>().apply {
            whenever(delayer.delay(capture())).thenAnswer { 
                firstValue()
            }
        }

delay(...)

argumentCaptor<() -> Unit>().apply {
            var invocationCount = 0

            whenever(delayer.delay(capture())).thenAnswer {
                if(invocationCount < times) {
                   ++invocationCount

                   firstValue()
               }
           }
        }

val httpLoggingInterceptor = HttpLoggingInterceptor().level = HttpLoggingInterceptor.Level.BODY

println("hello".apply {
		replace("h", "H")
	})
}

buttonRegister.isEnabled = ! (isEmpty(email) && isEmpty(password) && isEmpty(confirmPassword))

!

fillAdIds

tempAdIds

currentAdId

accessing non-final property in constructor

class KafkaService {

  val producer: KafkaProducer<String, String>

  init {
    val props = Properties()
    props[ProducerConfig.BOOTSTRAP_SERVERS_CONFIG] = "127.0.0.1:9092"
    props[ProducerConfig.CLIENT_ID_CONFIG] = "DemoProducer"
    props[ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG] = StringSerializer::class.java.name
    props[ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG] = StringSerializer::class.java.name

    producer = KafkaProducer(props)
  }

  fun sendToKafka(topic: String, message: String) {
    val producerRecord: ProducerRecord<String?, String> = ProducerRecord(topic, null, message)
    producer.send(producerRecord)
  }
}

class Response(val message: String, val path: String) {
  val timestamp: Long = Instant.now().toEpochMilli()

  var status: Int = 0

  lateinit var error: String

  companion object {
    fun clientError(message: String, path: String): Response {
      return Response(message, path).apply { status = 400; error = "Bad Request" }
    }

    fun serverError(message: String, path: String): Response {
      return Response(message, path).apply { status = 500; error = "Internal Server Error" }
    }
  }
}

?.

if

/** Matches [android.support.v7.app.AppCompatViewInflater.createView] content. */
val appCompatViewFactory = { clazz: Class<out View>, context: Context, _: Style<out View>? ->
    when (clazz) {
        TextView::class.java -> AppCompatTextView(context)
        Button::class.java -> AppCompatButton(context)
        ImageView::class.java -> AppCompatImageView(context)
        EditText::class.java -> AppCompatEditText(context)
        ...
        else -> null
    }
}

operator fun Double.times(vec: Vec) = when (vec) {
    is Vec2 -> vec.copy(this * vec.x, this * vec.y)
    is Vec3 -> vec.copy(this * vec.x, this * vec.y, this * vec.z)
}

as T

when

Vec

T