Skip to content

Instantly share code, notes, and snippets.

@olafurpg

olafurpg/arrow.txt

Created June 24, 2018 19:10
Show Gist options
  • Star 0 You must be signed in to star a gist
  • Fork 0 You must be signed in to fork a gist
  • Save olafurpg/9349c6fb189c9ecb762504cc488d2b07 to your computer and use it in GitHub Desktop.
Save olafurpg/9349c6fb189c9ecb762504cc488d2b07 to your computer and use it in GitHub Desktop.
Download ZIP
Raw
arrow.txt
finagle/finagle-core/src/test/scala/com/twitter/finagle/FilterTest.scala
calls += (this -> req)
val expected = List(F1 -> Input, F2 -> Input)
finagle/finagle-core/src/test/scala/com/twitter/finagle/context/MarshalledContextTest.scala
assert(ctx.marshal(env).toMap == Map(Buf.Utf8("a.key") -> Buf.Utf8("ok")))
Buf.Utf8("a.key") -> Buf.Utf8("ok"),
Buf.Utf8("b.key") -> Buf.U32BE(123)
Buf.Utf8("a.key") -> Buf.Utf8("ok"),
Buf.Utf8("b.key") -> Buf.U32BE(321)
Buf.Utf8("a.key") -> Buf.Utf8("ok"),
Buf.Utf8("b.key") -> Buf.U32BE(321)
Buf.Utf8("a.key") -> Buf.Utf8("ok"),
Buf.Utf8("b.key") -> Buf.U32BE(123)
Buf.Utf8("a.key") -> Buf.Utf8("ok"),
Buf.Utf8("b.key") -> Buf.U32BE(321)
Buf.Utf8("b.key") -> Buf.U32BE(333),
Buf.Utf8("bleep") -> Buf.Utf8("bloop")
Buf.Utf8("b.key") -> Buf.U32BE(333),
Buf.Utf8("bleep") -> Buf.Utf8("NOPE")
ctx.marshal(env).toMap == Map(Buf.Utf8("b.key") -> Buf.U32BE(30301952))
ctx.marshal(env).toMap == Map(Buf.Utf8("b.key") -> Buf.U64BE(30301952))
finagle/finagle-core/src/test/scala/com/twitter/finagle/util/RingTest.scala
case (map, which) => map + (which -> (map.getOrElse(which, 0) + 1))
finagle/finagle-core/src/test/scala/com/twitter/finagle/NamerTest.scala
Addr.Bound(addrs.toSet, Addr.Metadata(AddrWeightKey -> weight))
acts += p -> tup
finagle/finagle-core/src/test/scala/com/twitter/finagle/loadbalancer/P2CBalancerTest.scala
val work = (clock() + latency -> (schedule.getOrElse(
finagle/finagle-core/src/test/scala/com/twitter/finagle/loadbalancer/HeapBalancerTest.scala
map + (chosenNode -> (map.getOrElse(chosenNode, 0) + 1))
finagle/finagle-core/src/test/scala/com/twitter/finagle/naming/DefaultInterpreterTest.scala
Addr.Bound(addrs.toSet, Addr.Metadata(AddrWeightKey -> weight))
finagle/finagle-core/src/test/scala/com/twitter/finagle/NameTreeTest.scala
"~" -> None,
"/ok" -> Some(Set("/ok")),
"/ok & /ok1" -> Some(Set("/ok", "/ok1")),
"/ok & ~ & /blah & $" -> Some(Set("/ok", "/blah")),
"$ & $ & $" -> Some(Set.empty),
"~ & ~ & (~ | ~)" -> None,
"~ | /foo | /bar" -> Some(Set("/foo")),
"~ | $ | /blah" -> Some(Set.empty),
"~ | (~ | $) | /blah" -> Some(Set.empty),
"(~|$|/foo) & (/bar|/blah) & ~ & /FOO" -> Some(Set("/bar", "/FOO")),
"! | /ok" -> None,
"/ok & !" -> None,
"~ | /ok | !" -> Some(Set("/ok"))
finagle/finagle-core/src/test/scala/com/twitter/finagle/service/DelayedFactoryTest.scala
"Normal" -> (() => new BareDelayedHelper {}),
"Swapping" -> (() => new SwapOnBareHelper {})
"Normal" -> (() => new DefaultClosingHelper {}),
"Swapping" -> (() => new SwapOnCloseHelper {})
finagle/finagle-core/src/test/scala/com/twitter/finagle/builder/SourceTrackingMonitorTest.scala
sources = Map(Failure.Source.Service -> "tweet")
finagle/finagle-core/src/test/scala/com/twitter/finagle/builder/EndToEndTest.scala
"A -> B: Exception returned to A from B should include downstream address of B"
"A -> B -> C: Exception returned to B from C should include upstream address of A and downstream address of C"
"A -> B -> C: Exception returned from B to A should include downstream address of B"
finagle/finagle-core/src/test/scala/com/twitter/finagle/builder/ClientBuilderTest.scala
.failureAccrualParams(25 -> Duration.fromSeconds(10))
finagle/finagle-core/src/test/scala/com/twitter/finagle/client/StatsScopingTest.scala
val service = mkService(Addr.Metadata("zone" -> "foo")) {
Map(Seq("foo", "bar") -> 1, Seq("foo", "baz") -> 1) == stats.counters
finagle/finagle-core/src/test/scala/com/twitter/finagle/client/EndpointRecorderTest.scala
val bound = Addr.Bound(addrs.toSet, Addr.Metadata(AddrWeightKey -> 2.0))
finagle/finagle-core/src/test/scala/com/twitter/finagle/client/ClientRegistryTest.scala
"high" -> "2147483647",
"low" -> "0",
"idleTime" -> "Duration.Top",
"maxWaiters" -> "2147483647"
finagle/finagle-core/src/test/scala/com/twitter/finagle/client/AddrMetadataExtractionTest.scala
val metadata = Addr.Metadata("foo" -> "bar")
Await.result(verify(vaddr, name, metadata ++ Addr.Metadata("id" -> "baz")))
verify(vaddrBound, bound, metadata ++ Addr.Metadata("id" -> "/baz"))
Addr.Metadata("id" -> "/baz")
finagle/finagle-core/src/test/scala/com/twitter/finagle/client/LatencyCompensationTest.scala
metadata = Addr.Metadata("compensation" -> 2.seconds)
metadata = Addr.Metadata("compensation" -> 2.seconds)
metadata = Addr.Metadata("compensation" -> 2.seconds)
metadata = Addr.Metadata("compensation" -> 2.seconds)
finagle/finagle-core/src/test/scala/com/twitter/finagle/client/EndpointRegistryTest.scala
val bound = Addr.Bound(addrs.toSet, Addr.Metadata(AddrWeightKey -> 2.0))
val bound2 = Addr.Bound(addrs.toSet, Addr.Metadata(AddrWeightKey -> 3.0))
finagle/finagle-core/src/test/scala/com/twitter/finagle/factory/ServiceFactoryCacheTest.scala
factories += (i -> 0)
news += (i -> (1 + news.getOrElse(i, 0)))
factories = factories + (i -> (factories(i) + 1))
factories += (i -> (factories(i) - 1))
assert(factories == Map(1 -> 1))
assert(factories == Map(1 -> 1, 2 -> 1))
assert(factories == Map(1 -> 1, 2 -> 1, 3 -> 1))
assert(factories == Map(1 -> 1, 2 -> 1))
assert(factories == Map(1 -> 1, 2 -> 0))
assert(factories == Map(1 -> 0, 2 -> 0))
assert(news == Map(1 -> 1, 2 -> 1, 3 -> 1))
assert(factories == Map(1 -> 0, 3 -> 1))
assert(news == Map(1 -> 1, 2 -> 1, 3 -> 2))
assert(factories == Map(1 -> 2, 3 -> 1))
assert(news == Map(1 -> 1, 2 -> 1, 3 -> 2))
assert(factories == Map(1 -> 2, 3 -> 1, 2 -> 1))
assert(news == Map(1 -> 1, 2 -> 2, 3 -> 2))
finagle/finagle-core/src/test/scala/com/twitter/finagle/factory/StatsFactoryWrapperTest.scala
Map(List("failures", t.getClass.getName, rex.getClass.getName) -> 1)
finagle/finagle-core/src/test/scala/com/twitter/finagle/factory/BindingFactoryTest.scala
Seq("bind_latency_us") -> Seq(5678.0)
finagle/finagle-core/src/test/scala/com/twitter/finagle/factory/TrafficDistributorTest.scala
Address.Inet(new InetSocketAddress(port), Addr.Metadata(key -> weight))
finagle/finagle-core/src/main/scala/com/twitter/finagle/Failure.scala
copy(sources = sources + (key -> value))
finagle/finagle-core/src/main/scala/com/twitter/finagle/Stack.scala
copy(map + (param -> p))
finagle/finagle-core/src/main/scala/com/twitter/finagle/util/InetSocketAddressUtil.scala
/** converts 0.0.0.0 -> public ip in bound ip */
finagle/finagle-core/src/main/scala/com/twitter/finagle/util/StackRegistry.scala
duplicates += entry.name -> updated
registry += entry.name -> entry
duplicates += entry.name -> dups.drop(1)
finagle/finagle-core/src/main/scala/com/twitter/finagle/util/LoadService.scala
ents += (url.toURI -> loader)
finagle/finagle-core/src/main/scala/com/twitter/finagle/Resolver.scala
* Clients should only use this in scenarios where host -> IP map changes
finagle/finagle-core/src/main/scala/com/twitter/finagle/loadbalancer/Balancer.scala
val transferNodes = transfer.map(n => n.factory -> n).toMap
finagle/finagle-core/src/main/scala/com/twitter/finagle/server/ServerRegistry.scala
addrNames += (ia -> name)
finagle/finagle-core/src/main/scala/com/twitter/finagle/loadbalancer/LoadBalancerFactory.scala
yield Address.Inet(ia, metadata + (ReplicaKey -> i))
finagle/finagle-core/src/main/scala/com/twitter/finagle/netty3/Netty3Listener.scala
opts += "soLinger" -> (0: java.lang.Integer)
opts += "reuseAddress" -> (reuseAddr: java.lang.Boolean)
opts += "child.tcpNoDelay" -> (noDelay: java.lang.Boolean)
for (v <- backlog) opts += "backlog" -> (v: java.lang.Integer)
opts += "child.sendBufferSize" -> (v: java.lang.Integer)
opts += "child.receiveBufferSize" -> (v: java.lang.Integer)
for (v <- keepAlive) opts += "child.keepAlive" -> (v: java.lang.Boolean)
opts += "trafficClass" -> (v: java.lang.Integer)
opts += "child.trafficClass" -> (v: java.lang.Integer)
"soLinger" -> (0: java.lang.Integer),
"reuseAddress" -> java.lang.Boolean.TRUE,
"child.tcpNoDelay" -> java.lang.Boolean.TRUE
finagle/finagle-core/src/main/scala/com/twitter/finagle/netty3/socks/SocksConnectHandler.scala
setting.typeByte -> setting
finagle/finagle-core/src/main/scala/com/twitter/finagle/netty3/Netty3Transporter.scala
"tcpNoDelay" -> java.lang.Boolean.TRUE,
"reuseAddress" -> java.lang.Boolean.TRUE,
"connectTimeoutMillis" -> (1000L: java.lang.Long)
opts += "connectTimeoutMillis" -> ((connectTimeout + compensation).inMilliseconds: java.lang.Long)
opts += "tcpNoDelay" -> (noDelay: java.lang.Boolean)
opts += "reuseAddress" -> (reuseAddr: java.lang.Boolean)
for (v <- keepAlive) opts += "keepAlive" -> (v: java.lang.Boolean)
for (s <- sendBufSize) opts += "sendBufferSize" -> (s: java.lang.Integer)
for (s <- recvBufSize) opts += "receiveBufferSize" -> (s: java.lang.Integer)
opts += "trafficClass" -> (v: java.lang.Integer)
finagle/finagle-core/src/main/scala/com/twitter/finagle/Group.scala
case el if f.isDefinedAt(el) => el -> f(el)
finagle/finagle-core/src/main/scala/com/twitter/finagle/Filter.scala
* [ReqIn -> (ReqOut -> RepIn) -> RepOut]
* [ThriftIn -> (String -> Int) -> ThriftOut]
finagle/finagle-core/src/main/scala/com/twitter/finagle/addr/WeightedAddress.scala
Address.Inet(ia, metadata + (weightKey -> weight))
exp.Address.ServiceFactory(sf, metadata + (weightKey -> weight))
finagle/finagle-core/src/main/scala/com/twitter/finagle/client/EndpointRegistry.scala
dtabMap += ((dtab, mutable.Map(path -> observation)))
val endpointMap: EndpointMap = mutable.Map(path -> observation)
val dtabMap: DtabMap = mutable.Map(dtab -> endpointMap)
finagle/finagle-core/src/main/scala/com/twitter/finagle/client/AddrMetadataExtraction.scala
case bound: Name.Bound => Addr.Metadata("id" -> bound.idStr)
finagle/finagle-core/src/main/scala/com/twitter/finagle/factory/ServiceFactoryCache.scala
cache += (key -> factory)
cache = cache - evicted + (key -> factory)
finagle/finagle-core/src/main/scala/com/twitter/finagle/factory/TrafficDistributor.scala
cache + (weight -> newCacheEntry)
finagle/finagle-core/src/main/scala/com/twitter/finagle/stats/SummarizingStatsReceiver.scala
_gauges += (name -> (() => f))
case (names, gauge) => variableName(names) -> gauge().toString
finagle/finagle-mysql/src/main/scala/com/twitter/finagle/mysql/Capability.scala
"CLIENT_LONG_PASSWORD" -> LongPassword,
"CLIENT_FOUND_ROWS" -> FoundRows,
"CLIENT_LONG_FLAG" -> LongFlag,
"CLIENT_CONNECT_WITH_DB" -> ConnectWithDB,
"CLIENT_NO_SCHEMA" -> NoSchema,
"CLIENT_COMPRESS" -> Compress,
"CLIENT_ODBC" -> ODBC,
"CLIENT_LOCAL_FILES" -> LocalFiles,
"CLIENT_IGNORE_SPACE" -> IgnoreSpace,
"CLIENT_PROTOCOL_41" -> Protocol41,
"CLIENT_INTERACTIVE" -> Interactive,
"CLIENT_SSL" -> SSL,
"CLIENT_IGNORE_SIGPIPE" -> IgnoreSigPipe,
"CLIENT_TRANSACTIONS" -> Transactions,
"CLIENT_SECURE_CONNECTION" -> SecureConnection,
"CLIENT_MULTI_STATEMENTS" -> MultiStatements,
"CLIENT_MULTI_RESULTS" -> MultiResults
finagle/finagle-mysql/src/main/scala/com/twitter/finagle/mysql/Result.scala
// A name -> index map used to allow quick lookups for rows based on name.
finagle/finagle-cacheresolver/src/main/scala/com/twitter/finagle/cacheresolver/CacheNodeMetadata.scala
Addr.Metadata(key -> metadata)
finagle/finagle-memcached/src/test/scala/com/twitter/finagle/memcached/unit/util/ParserUtilsTest.scala
"123" -> true,
"1" -> true,
"" -> false,
" " -> false,
"x" -> false,
" 9" -> false,
"9 " -> false
finagle/finagle-memcached/src/test/scala/com/twitter/finagle/memcached/unit/util/NotFoundTest.scala
val map = set.map(x => x -> x).toMap
assert(removeAll(map, elems) == Map(8 -> 8, 9 -> 9, 10 -> 10))
removeAll(map, elems) == Map(6 -> 6, 7 -> 7, 8 -> 8, 9 -> 9, 10 -> 10)
finagle/finagle-memcached/src/test/scala/com/twitter/finagle/memcached/unit/GetResultTest.scala
hits = Map("h1" -> value1),
failures = Map("f1" -> ex1)
hits = Map("h2" -> value2),
failures = Map("f2" -> ex2)
hits = Map("h1" -> value1, "h2" -> value2),
failures = Map("f1" -> ex1, "f2" -> ex2)
hits = Map("h" + i -> mock[Value]),
failures = Map("f" + i -> mock[Exception])
finagle/finagle-memcached/src/test/scala/com/twitter/finagle/memcached/unit/PoolingReadRepairClientTest.scala
val full: MockClient = new MockClient(Map("key" -> "value", "foo" -> "bar"))
val partial: MockClient = new MockClient(Map("key" -> "value"))
finagle/finagle-memcached/src/test/scala/com/twitter/finagle/memcached/unit/MockClientTest.scala
val memcache = new MockClient(Map("key" -> "value")).withStrings
val memcache = new MockClient(Map("key" -> "value")).withStrings
val memcache = new MockClient(Map("key" -> "value")).withStrings
val memcache = new MockClient(Map("key" -> "value")).withStrings
val memcache = new MockClient(Map("key" -> "value")).withStrings
val memcache = new MockClient(Map("key" -> "value")).withStrings
val memcache = new MockClient(Map("key" -> "value")).withStrings
new MockClient(Map("key" -> "value", "count" -> "1")).withStrings
new MockClient(Map("key" -> "value", "count" -> "1")).withStrings
new MockClient(Map("key" -> "value", "count" -> "1")).withStrings
assert(oneKey == Map("key" -> Buf.Utf8("value")))
finagle/finagle-memcached/src/test/scala/com/twitter/finagle/memcached/unit/protocol/text/server/DecodingToCommandTest.scala
"expectedTime" -> "allowedDelta",
ExpectedTimeTable(0, Time.epoch) -> 0.seconds,
ExpectedTimeTable(200.seconds.fromNow.inSeconds, 200.seconds.fromNow) -> 1.seconds,
ExpectedTimeTable(200, 200.seconds.fromNow) -> 1.seconds
finagle/finagle-memcached/src/test/scala/com/twitter/finagle/memcached/unit/KetamaClientTest.scala
CacheNode("10.0.1.1", 11211, 600) -> newMock(),
CacheNode("10.0.1.2", 11211, 300) -> newMock(),
CacheNode("10.0.1.3", 11211, 200) -> newMock(),
CacheNode("10.0.1.4", 11211, 350) -> newMock(),
CacheNode("10.0.1.5", 11211, 1000) -> newMock(),
CacheNode("10.0.1.6", 11211, 800) -> newMock(),
CacheNode("10.0.1.7", 11211, 950) -> newMock(),
CacheNode("10.0.1.8", 11211, 100) -> newMock()
val ipToService = clients.map { case (key, service) => key.host -> service }.toMap
nodeA -> serviceA,
nodeB -> serviceB
finagle/finagle-memcached/src/test/scala/com/twitter/finagle/memcached/integration/SimpleClientTest.scala
"foo" -> "bar",
"baz" -> "boing"
"foos" -> (("xyz", "1")), // the "cas unique" values are predictable from a fresh memcached
"bazs" -> (("zyx", "3"))
finagle/finagle-memcached/src/test/scala/com/twitter/finagle/memcached/integration/MemcachedTest.scala
assert(result == Map("foo" -> "bar", "baz" -> "boing"))
"foos" -> (("xyz", "1")), // the "cas unique" values are predictable from a fresh memcached
"bazs" -> (("zyx", "3"))
finagle/finagle-memcached/src/main/scala/com/twitter/finagle/memcached/MockClient.scala
hits += (key -> Value(
finagle/finagle-memcached/src/main/scala/com/twitter/finagle/memcached/replication/ReplicationClient.scala
k -> toReplicationStatus(replicasResult)
k -> attachCas(toReplicationStatus(replicasResult), results, k)
GetsResult(GetResult(hits = Map(key -> newValue)))
key -> SimpleReplicationFailure(
finagle/finagle-memcached/src/main/scala/com/twitter/finagle/memcached/Client.scala
key -> KetamaNode(key.identifier, node.weight, underlying)
key -> Node(node, NodeState.Live)
finagle/finagle-mux/src/test/scala/com/twitter/finagle/mux/HandshakeTest.scala
Seq(wrappedBuffer("key".getBytes) -> wrappedBuffer("value".getBytes))
Seq(wrappedBuffer("key".getBytes) -> wrappedBuffer("value".getBytes))
finagle/finagle-mux/src/main/scala/com/twitter/finagle/mux/transport/Message.scala
headers += (k -> v)
finagle/finagle-serversets/src/test/scala/com/twitter/finagle/serverset2/Zk2ResolverTest.scala
serverSet.join(serviceAddr, Map("epep" -> epepAddr).asJava, shardId)
finagle/finagle-serversets/src/test/scala/com/twitter/finagle/serverset2/ServiceDiscovererTest.scala
ep(port1) -> 1.1,
ep(port2) -> 2.8,
ep(3) -> 3.1,
ep(4) -> 1.0
finagle/finagle-serversets/src/test/scala/com/twitter/finagle/serverset2/EntryTest.scala
ep.names.map(_ -> ep)
finagle/finagle-serversets/src/test/scala/com/twitter/finagle/zookeeper/ZookeeperServerSetClusterTest.scala
name -> new Endpoint(addr.getHostName, addr.getPort)
cluster.join(localAddress, Map("alt" -> altLocalAddress))
Map("alt" -> altLocalAddress).asJava,
registerHost(remoteAddress, Map("other-endpoint" -> otherRemoteAddress))
finagle/finagle-serversets/src/test/scala/com/twitter/finagle/zookeeper/ZkResolverTest.scala
Map[String, InetSocketAddress]("blah" -> blahAddr.addr).asJava,
Map[String, InetSocketAddress]("blah" -> blahAddr.addr).asJava,
sockAddr.getPort.toString -> sockAddr
finagle/finagle-serversets/src/main/scala/com/twitter/finagle/serverset2/Entry.scala
"DEAD" -> Dead,
"STARTING" -> Starting,
"ALIVE" -> Alive,
"STOPPING" -> Stopping,
"STOPPED" -> Stopped,
"WARNING" -> Warning,
"UNKNOWN" -> Unknown
finagle/finagle-serversets/src/main/scala/com/twitter/finagle/serverset2/ServiceDiscoverer.scala
ent -> w
finagle/finagle-serversets/src/main/scala/com/twitter/finagle/serverset2/addr/ZkMetadata.scala
Addr.Metadata(key -> metadata)
finagle/finagle-serversets/src/main/scala/com/twitter/finagle/serverset2/Zk2Resolver.scala
(host, port, metadata + (WeightedAddress.weightKey -> weight))
finagle/finagle-serversets/src/main/scala/com/twitter/finagle/serverset2/ZkSession.scala
immutableDataOf(path).map(path -> _)
finagle/finagle-serversets/src/main/scala/com/twitter/finagle/serverset2/client/ClientBuilder.scala
"hosts" -> hosts,
"sessionTimeout" -> sessionTimeout,
"statsReceiver" -> statsReceiver,
"readOnlyOK" -> readOnlyOK,
"sessionId" -> sessionId,
"password" -> password,
"timer" -> timer
finagle/finagle-serversets/src/main/scala/com/twitter/finagle/serverset2/client/apache/types.scala
CreateMode.Ephemeral -> org.apache.zookeeper.CreateMode.EPHEMERAL,
CreateMode.EphemeralSequential -> org.apache.zookeeper.CreateMode.EPHEMERAL_SEQUENTIAL,
CreateMode.Persistent -> org.apache.zookeeper.CreateMode.PERSISTENT,
CreateMode.PersistentSequential -> org.apache.zookeeper.CreateMode.PERSISTENT_SEQUENTIAL
EventType.NodeChildrenChanged -> NodeEvent.ChildrenChanged,
EventType.NodeCreated -> NodeEvent.Created,
EventType.NodeDataChanged -> NodeEvent.DataChanged,
EventType.NodeDeleted -> NodeEvent.Deleted
KeeperState.Unknown -> SessionState.Unknown,
KeeperState.AuthFailed -> SessionState.AuthFailed,
KeeperState.Disconnected -> SessionState.Disconnected,
KeeperState.Expired -> SessionState.Expired,
KeeperState.NoSyncConnected -> SessionState.NoSyncConnected,
KeeperState.SyncConnected -> SessionState.SyncConnected,
KeeperState.SaslAuthenticated -> SessionState.SaslAuthenticated,
KeeperState.ConnectedReadOnly -> SessionState.ConnectedReadOnly
finagle/finagle-exception/src/main/scala/com/twitter/finagle/exception/ServiceException.scala
"name" -> name,
"exceptionContents" -> ExceptionContents(e).jsonValue,
"timestamp" -> timestamp.inMillis,
"traceId" -> traceId
"exceptionClass" -> e.getClass.getName,
"message" -> e.getMessage,
"stackTrace" -> generateStackTrace(e.getStackTrace)
finagle/finagle-stats/src/test/scala/com/twitter/finagle/stats/JsonExporterTest.scala
"jvm_uptime" -> 15.0,
"abc" -> 42,
"ill_be_partially_matched" -> 1
finagle/finagle-stats/src/main/scala/com/twitter/finagle/stats/CounterDeltas.scala
key -> Long.box(pd.delta)
finagle/finagle-stats/src/main/scala/com/twitter/finagle/stats/StatsFormatter.scala
results += histoName(name, "count") -> snapshot.count
results += histoName(name, "sum") -> snapshot.sum
results += histoName(name, labelAverage) -> snapshot.avg
results += histoName(name, labelMin) -> snapshot.min
results += histoName(name, labelMax) -> snapshot.max
results += percentileName -> p.getValue
case ("jvm_num_cpus", n) => "jvm_available_processors" -> n
case ("jvm_classes_current_loaded", n) => "jvm_class_loaded_count" -> n
"jvm_class_total_loaded_count" -> n
"jvm_class_unloaded_count" -> n
case ("jvm_gc_msec", n) => "jvm_gc_collection_time_ms" -> n
case ("jvm_gc_cycles", n) => "jvm_gc_collection_count" -> n
"jvm_memory_heap_mb_committed" -> inMegabytes(n)
case ("jvm_heap_max", n) => "jvm_memory_heap_mb_max" -> inMegabytes(n)
case ("jvm_heap_used", n) => "jvm_memory_heap_mb_used" -> inMegabytes(n)
"jvm_memory_non_heap_mb_committed" -> inMegabytes(n)
"jvm_memory_non_heap_mb_max" -> inMegabytes(n)
"jvm_memory_non_heap_mb_used" -> inMegabytes(n)
case ("jvm_thread_count", n) => "jvm_threads_active" -> n
case ("jvm_thread_daemon_count", n) => "jvm_threads_daemon" -> n
case ("jvm_thread_peak_count", n) => "jvm_threads_peak" -> n
case ("jvm_start_time", n) => "jvm_time_ms" -> n
case ("jvm_uptime", n) => "jvm_uptime_secs" -> inSeconds(n)
case (gcCycles(gc), n) => s"jvm_gc_${gc}_collection_count" -> n
case (gcMsec(gc), n) => s"jvm_gc_${gc}_collection_time_ms" -> n
finagle/finagle-thrift/src/test/scala/com/twitter/finagle/thrift/ThriftTest.scala
"binary" -> new TBinaryProtocol.Factory()
// "compact" -> new TCompactProtocol.Factory()
// "json" -> new TJSONProtocol.Factory()
"builder" -> newBuilderClient,
"api" -> newAPIClient
"builder" -> newBuilderServer,
"api" -> newAPIServer
finagle/finagle-mdns/src/main/scala/com/twitter/finagle/mdns/MDNS.scala
Addr.Metadata(key -> metadata)
finagle/finagle-http/src/test/scala/com/twitter/finagle/http/HeaderMapTest.scala
request.headerMap += "Cookie" -> "2"
request.headerMap += "date" -> date
finagle/finagle-http/src/test/scala/com/twitter/finagle/http/MapHeaderMapTest.scala
val map = MapHeaderMap("a" -> "1", "b" -> "2", "a" -> "3")
("a" -> "1"),
("a" -> "3"),
("b" -> "2")
map += "a" -> "1"
map += "b" -> "2"
map += "a" -> "3"
assert(map.iterator.toList.sorted == List(("a" -> "3"), ("b" -> "2")))
("a" -> "1"),
("a" -> "3"),
("b" -> "2")
assert(map.iterator.toList.sorted == List(("a" -> "3"), ("b" -> "2")))
val map = MapHeaderMap("a" -> "1", "b" -> "2", "a" -> "3")
finagle/finagle-http/src/test/scala/com/twitter/finagle/http/codec/ConnectionManagerTest.scala
makeResponse(Version.Http11, Fields.ContentLength -> "1"),
makeRequest(Version.Http11, "Connection" -> "close"),
finagle/finagle-http/src/test/scala/com/twitter/finagle/http/path/PathTest.scala
assert(/:.unapply(p) == util.Try(parts.head -> Path(parts.tail)).toOption)
(Path("/test.json") :? ParamMap("a" -> "1", "b" -> "2")) match {
(Path("/test.json") :? ParamMap("a" -> "1", "b" -> "2")) match {
(Path("/test.json") :? ParamMap("a" -> "1", "b" -> "2")) match {
(Path("/test.json") :? ParamMap("a" -> "1", "b" -> "2")) match {
"i" -> "1",
"l" -> "2147483648",
"d" -> "1.3"
case Method.Get -> Root / "test.json" => true
finagle/finagle-http/src/test/scala/com/twitter/finagle/http/MapParamMapTest.scala
assert(MapParamMap("key" -> "value").get("key") == Some("value"))
val paramMap = MapParamMap("a" -> "1", "b" -> "2", "a" -> "3")
val paramMap = MapParamMap("a" -> "1", "b" -> "2", "a" -> "3")
("a" -> "1"),
("a" -> "3"),
("b" -> "2")
val paramMap = MapParamMap() + ("a" -> "1") + ("b" -> "2") + ("a" -> "3")
val paramMap = MapParamMap("a" -> "1", "b" -> "2", "a" -> "3") - "a" - "b"
finagle/finagle-http/src/test/scala/com/twitter/finagle/http/RequestBuilderTest.scala
"k1" -> "v1",
"k2" -> "v2",
"k3" -> "v3"
finagle/finagle-http/src/test/scala/com/twitter/finagle/http/EmptyParamMapTest.scala
val map = EmptyParamMap + ("key" -> "value")
finagle/finagle-http/src/test/scala/com/twitter/finagle/http/RequestTest.scala
Request("/", "q" -> "twitter"),
Request("q" -> "twitter")
"/" -> "/",
"/search.json" -> "/search.json",
"/search.json?" -> "/search.json",
"/search.json?q=twitter" -> "/search.json",
"/search.json%3Fq=twitter" -> "/search.json%3Fq=twitter"
"/search.json" -> "json",
"/1.1/search/tweets.json" -> "json",
"/1.1/search/tweets.JSON" -> "json",
"/1.1/search/tweets" -> "",
"/1.1/se.arch/tweets" -> "",
"/1.1/se.arch/tweets.json" -> "json",
"/search" -> "",
"/search." -> "",
"/" -> "",
"/." -> ""
val request = Request("/search.json", "q" -> "twitter")
val request = Request("/search.json", "q" -> "twitter")
val originalRequest = Request("/", "foo" -> "bar")
Request.queryString("/search.json", "q" -> "twitter") == "/search.json?q=twitter"
Request.queryString("/search.json", Map("q" -> "twitter")) == "/search.json?q=twitter"
assert(Request.queryString("q" -> "twitter") == "?q=twitter")
assert(Request.queryString(Map("q" -> "twitter")) == "?q=twitter")
assert(Request.queryString("q!" -> "twitter!") == "?q%21=twitter%21")
finagle/finagle-http/src/test/scala/com/twitter/finagle/http/filter/ExceptionFilterTest.scala
val request = Request("exception" -> "true")
val request = Request("throw" -> "true")
val request = Request("cancel" -> "true")
finagle/finagle-http/src/test/scala/com/twitter/finagle/http/filter/AddResponseHeadersFilterTest.scala
val filter = new AddResponseHeadersFilter(Map("X-Money" -> "cash"))
assert(result == Map("X-Money" -> "cash"))
finagle/finagle-http/src/test/scala/com/twitter/finagle/http/service/RoutingServiceTest.scala
case Get -> Root / "test.json" => NullService
finagle/finagle-http/src/test/scala/com/twitter/finagle/http/filter/JsonpFilterTest.scala
val request = Request("/test.json", "callback" -> "mycallback")
Request("/test.json", "callback" -> "mycallback", "not_json" -> "t")
val request = Request("/test.json", "callback" -> "mycallback")
val request = Request("/test.json", "callback" -> "")
finagle/finagle-http/src/test/scala/com/twitter/finagle/http/service/HttpResponseClassifierTest.scala
classifier(ReqRep(Request("fail" -> "1"), rep(Status.Ok)))
finagle/finagle-http/src/test/scala/com/twitter/finagle/http/ProxyCredentialsTest.scala
"http_proxy_user" -> "foo",
"http_proxy_pass" -> "bar"
finagle/finagle-http/src/test/scala/com/twitter/finagle/http/exp/MultipartTest.scala
"abc" -> Seq("foo", "bar"),
"def" -> Seq("123")
finagle/finagle-http/src/test/scala/com/twitter/finagle/http/MessageTest.scala
"x; charset=a" -> "a",
"x;charset=a" -> "a",
"x; charset=a " -> "a",
"x;y;charset=a" -> "a",
"x; charset=" -> "",
"x; charset==" -> "=",
"x; charset" -> null,
"x" -> null,
";;;;;;" -> null
("x; charset=a" -> "b") -> "x;charset=b",
("x" -> "b") -> "x;charset=b",
("x;p1" -> "b") -> "x;charset=b;p1",
("x;p1; p2 ;p3" -> "b") -> "x;charset=b;p1; p2 ;p3",
("x;p1;charset=a;p3" -> "b") -> "x;p1;charset=b;p3",
("x;" -> "b") -> "x;charset=b",
(";" -> "b") -> ";charset=b",
("" -> "b") -> ";charset=b"
"application/json" -> "application/json",
"application/json;charset=utf-8" -> "application/json",
"" -> "",
";" -> "",
";;;;;;;;;;" -> "",
"application/json;" -> "application/json",
" application/json ; charset=utf-8 " -> "application/json",
"APPLICATION/JSON" -> "application/json"
("x" -> "y") -> "y",
("x; charset=a" -> "y") -> "y; charset=a",
("x;p1; p2 ;p3" -> "y") -> "y;p1; p2 ;p3",
("x;" -> "y") -> "y",
(";" -> "y") -> "y",
("" -> "y") -> "y"
finagle/finagle-http/src/test/scala/com/twitter/finagle/http/ParamMapTest.scala
val params = request.params + ("lang" -> "en")
finagle/finagle-http/src/main/scala/com/twitter/finagle/http/Codec.scala
!_streaming -> new PayloadSizeFilter[Request, Response](
finagle/finagle-http/src/main/scala/com/twitter/finagle/http/codec/HttpDtab.scala
((0 until Maxsize) map (i => i -> "%02d".format(i))).toMap
finagle/finagle-http/src/main/scala/com/twitter/finagle/http/path/Path.scala
object -> {
* case Methd.Get -> Root / "test.json" => ...
finagle/finagle-http/src/main/scala/com/twitter/finagle/http/Status.scala
100 -> Continue,
101 -> SwitchingProtocols,
102 -> Processing,
200 -> Ok,
201 -> Created,
202 -> Accepted,
203 -> NonAuthoritativeInformation,
204 -> NoContent,
205 -> ResetContent,
206 -> PartialContent,
207 -> MultiStatus,
300 -> MultipleChoices,
301 -> MovedPermanently,
302 -> Found,
303 -> SeeOther,
304 -> NotModified,
305 -> UseProxy,
307 -> TemporaryRedirect,
400 -> BadRequest,
401 -> Unauthorized,
402 -> PaymentRequired,
403 -> Forbidden,
404 -> NotFound,
405 -> MethodNotAllowed,
406 -> NotAcceptable,
407 -> ProxyAuthenticationRequired,
408 -> RequestTimeout,
409 -> Conflict,
410 -> Gone,
411 -> LengthRequired,
412 -> PreconditionFailed,
413 -> RequestEntityTooLarge,
414 -> RequestURITooLong,
415 -> UnsupportedMediaType,
416 -> RequestedRangeNotSatisfiable,
417 -> ExpectationFailed,
420 -> EnhanceYourCalm,
422 -> UnprocessableEntity,
423 -> Locked,
424 -> FailedDependency,
425 -> UnorderedCollection,
426 -> UpgradeRequired,
428 -> PreconditionRequired,
429 -> TooManyRequests,
431 -> RequestHeaderFieldsTooLarge,
499 -> ClientClosedRequest,
500 -> InternalServerError,
501 -> NotImplemented,
502 -> BadGateway,
503 -> ServiceUnavailable,
504 -> GatewayTimeout,
505 -> HttpVersionNotSupported,
506 -> VariantAlsoNegotiates,
507 -> InsufficientStorage,
510 -> NotExtended,
511 -> NetworkAuthenticationRequired
Continue -> "Continue",
SwitchingProtocols -> "Switching Protocols",
Processing -> "Processing",
Ok -> "OK",
Created -> "Created",
Accepted -> "Accepted",
NonAuthoritativeInformation -> "Non-Authoritative Information",
NoContent -> "No Content",
ResetContent -> "Reset Content",
PartialContent -> "Partial Content",
MultiStatus -> "Multi-Status",
MultipleChoices -> "Multiple Choices",
MovedPermanently -> "Moved Permanently",
Found -> "Found",
SeeOther -> "See Other",
NotModified -> "Not Modified",
UseProxy -> "Use Proxy",
TemporaryRedirect -> "Temporary Redirect",
BadRequest -> "Bad Request",
Unauthorized -> "Unauthorized",
PaymentRequired -> "Payment Required",
Forbidden -> "Forbidden",
NotFound -> "Not Found",
MethodNotAllowed -> "Method Not Allowed",
NotAcceptable -> "Not Acceptable",
ProxyAuthenticationRequired -> "Proxy Authentication Required",
RequestTimeout -> "Request Timeout",
Conflict -> "Conflict",
Gone -> "Gone",
LengthRequired -> "Length Required",
PreconditionFailed -> "Precondition Failed",
RequestEntityTooLarge -> "Request Entity Too Large",
RequestURITooLong -> "Request-URI Too Long",
UnsupportedMediaType -> "Unsupported Media Type",
RequestedRangeNotSatisfiable -> "Requested Range Not Satisfiable",
ExpectationFailed -> "Expectation Failed",
EnhanceYourCalm -> "Enhance Your Calm",
UnprocessableEntity -> "Unprocessable Entity",
Locked -> "Locked",
FailedDependency -> "Failed Dependency",
UnorderedCollection -> "Unordered Collection",
UpgradeRequired -> "Upgrade Required",
PreconditionRequired -> "Precondition Required",
TooManyRequests -> "Too Many Requests",
RequestHeaderFieldsTooLarge -> "Request Header Fields Too Large",
ClientClosedRequest -> "Client Closed Request",
InternalServerError -> "Internal Server Error",
NotImplemented -> "Not Implemented",
BadGateway -> "Bad Gateway",
ServiceUnavailable -> "Service Unavailable",
GatewayTimeout -> "Gateway Timeout",
HttpVersionNotSupported -> "HTTP Version Not Supported",
VariantAlsoNegotiates -> "Variant Also Negotiates",
InsufficientStorage -> "Insufficient Storage",
NotExtended -> "Not Extended",
NetworkAuthenticationRequired -> "Network Authentication Required"
finagle/finagle-example/src/main/scala/com/twitter/finagle/example/redis/RedisClient.scala
println("Setting foo -> bar...")
finagle/finagle-redis/src/test/scala/com/twitter/finagle/redis/commands/hash/HashClientIntegrationSuite.scala
Await.result(client.hMSet(foo, Map(baz -> bar, moo -> boo)))
client.hMSet(foo, Map(baz -> bar, moo -> StringToChannelBuffer("")))
Await.result(client.hMSet(foo, Map(baz -> bar, moo -> boo)))
finagle/finagle-redis/src/test/scala/com/twitter/finagle/redis/commands/sorted-set/SortedSetCodecSuite.scala
"foo -inf +inf" -> ZCount(
"foo (1.0 3.0" -> ZCount(
finagle/finagle-redis/src/test/scala/com/twitter/finagle/redis/commands/string/StringClientIntegrationSuite.scala
Await.result(client.mSet(Map(foo -> bar, bar -> baz)))
Await.result(client.mSetNx(Map(foo -> bar, baz -> foo, boo -> moo))) == false
assert(Await.result(client.mSetNx(Map(baz -> foo, boo -> moo))) == true)
finagle/finagle-redis/src/test/scala/com/twitter/finagle/redis/commands/string/StringClientServerIntegrationSuite.scala
StringToChannelBuffer("thing") -> StringToChannelBuffer("thang"),
foo -> bar,
StringToChannelBuffer("stuff") -> StringToChannelBuffer("bleh")
StringToChannelBuffer("msnx.key1") -> StringToChannelBuffer("Hello"),
StringToChannelBuffer("msnx.key2") -> StringToChannelBuffer("there")
StringToChannelBuffer("msnx.key2") -> StringToChannelBuffer("there"),
StringToChannelBuffer("msnx.key3") -> StringToChannelBuffer("world")
finagle/finagle-redis/src/test/scala/com/twitter/finagle/redis/commands/string/StringCodecSuite.scala
assert(nkv == Map("foo" -> "bar baz", "bar" -> "Hello"))
finagle/finagle-redis/src/main/scala/com/twitter/finagle/redis/protocol/Command.scala
DEL -> { Del(_) },
DUMP -> { Dump(_) },
EXISTS -> { Exists(_) },
EXPIRE -> { Expire(_) },
EXPIREAT -> { ExpireAt(_) },
KEYS -> { Keys(_) },
MOVE -> { Move(_) },
PERSIST -> { Persist(_) },
PEXPIRE -> { PExpire(_) },
PEXPIREAT -> { PExpireAt(_) },
PTTL -> { PTtl(_) },
RANDOMKEY -> { _ =>
RENAME -> { Rename(_) },
RENAMENX -> { RenameNx(_) },
SCAN -> { Scan(_) },
TTL -> { Ttl(_) },
TYPE -> { Type(_) },
APPEND -> { Append(_) },
BITCOUNT -> { BitCount(_) },
BITOP -> { BitOp(_) },
DECR -> { Decr(_) },
DECRBY -> { DecrBy(_) },
GET -> { Get(_) },
GETBIT -> { GetBit(_) },
GETRANGE -> { GetRange(_) },
GETSET -> { GetSet(_) },
INCR -> { Incr(_) },
INCRBY -> { IncrBy(_) },
MGET -> { MGet(_) },
MSET -> { MSet(_) },
MSETNX -> { MSetNx(_) },
PSETEX -> { PSetEx(_) },
SET -> { Set(_) },
SETBIT -> { SetBit(_) },
SETEX -> { SetEx(_) },
SETNX -> { SetNx(_) },
SETRANGE -> { SetRange(_) },
STRLEN -> { Strlen(_) },
ZADD -> { ZAdd(_) },
ZCARD -> { ZCard(_) },
ZCOUNT -> { ZCount(_) },
ZINCRBY -> { ZIncrBy(_) },
ZINTERSTORE -> { ZInterStore(_) },
ZRANGE -> { ZRange(_) },
ZRANGEBYSCORE -> { ZRangeByScore(_) },
ZRANK -> { ZRank(_) },
ZREM -> { ZRem(_) },
ZREMRANGEBYRANK -> { ZRemRangeByRank(_) },
ZREMRANGEBYSCORE -> { ZRemRangeByScore(_) },
ZREVRANGE -> { ZRevRange(_) },
ZREVRANGEBYSCORE -> { ZRevRangeByScore(_) },
ZREVRANK -> { ZRevRank(_) },
ZSCORE -> { ZScore(_) },
ZUNIONSTORE -> { ZUnionStore(_) },
BADD -> { BAdd(_) },
BCARD -> { BCard(_) },
BREM -> { BRem(_) },
BGET -> { BGet(_) },
FLUSHALL -> { _ =>
FLUSHDB -> { _ =>
SELECT -> { Select(_) },
AUTH -> { Auth(_) },
INFO -> { Info(_) },
QUIT -> { _ =>
SLAVEOF -> { SlaveOf(_) },
CONFIG -> { Config(_) },
HDEL -> { HDel(_) },
HEXISTS -> { HExists(_) },
HGET -> { HGet(_) },
HGETALL -> { HGetAll(_) },
HINCRBY -> { HIncrBy(_) },
HKEYS -> { HKeys(_) },
HMGET -> { HMGet(_) },
HMSET -> { HMSet(_) },
HSCAN -> { HScan(_) },
HSET -> { HSet(_) },
HSETNX -> { HSetNx(_) },
HVALS -> { HVals(_) },
LLEN -> { LLen(_) },
LINDEX -> { LIndex(_) },
LINSERT -> { LInsert(_) },
LPOP -> { LPop(_) },
LPUSH -> { LPush(_) },
LREM -> { LRem(_) },
LSET -> { LSet(_) },
LRANGE -> { LRange(_) },
RPUSH -> { RPush(_) },
RPOP -> { RPop(_) },
LTRIM -> { LTrim(_) },
SADD -> { SAdd(_) },
SMEMBERS -> { SMembers(_) },
SISMEMBER -> { SIsMember(_) },
SCARD -> { SCard(_) },
SREM -> { SRem(_) },
SPOP -> { SPop(_) },
SRANDMEMBER -> { SRandMember(_) },
SINTER -> { SInter(_) },
DISCARD -> { _ =>
EXEC -> { _ =>
MULTI -> { _ =>
UNWATCH -> { _ =>
WATCH -> { Watch(_) },
PFADD -> { PFAdd(_) },
PFCOUNT -> { PFCount(_) },
PFMERGE -> { PFMerge(_) }
finagle/finagle-http-netty4/src/test/scala/com/twitter/finagle/http-netty4/BijectionsTest.scala
test("netty http request -> finagle") {
test("netty http response -> finagle") {
test("finagle http response -> netty") {
test("finagle http request -> netty") {
finagle/finagle-http-netty4/src/test/scala/com/twitter/finagle/http-netty4/Netty4HeaderMapTest.scala
e.getKey -> e.getValue
assert(all == Set("key" -> "val", "qux" -> "something"))
assert(wrapper.toSet == Set("qux" -> "something"))
finagle/finagle-http-netty4/src/main/scala/com/twitter/finagle/http-netty4/Netty4HeaderMap.scala
entry.getKey -> entry.getValue
finagle/finagle-benchmark/src/main/scala/com/twitter/finagle/loadbalancer/Simulation.scala
0.5 -> between(min, p50),
0.4 -> between(p50, p90),
0.05 -> between(p90, p95),
0.04 -> between(p95, p99),
0.009 -> between(p99, p999),
0.0009 -> between(p999, p9999)
finagle/finagle-benchmark/src/main/scala/com/twitter/finagle/memcached/util/NotFoundBenchmark.scala
k -> k
finagle/finagle-commons-stats/src/main/scala/com/twitter/finagle/stats/CommonsStatsReceiver.scala
counters += (name -> counter)
stats += (name -> stat)
shapeless/core/src/test/scala_2.11+/shapeless/labelledgeneric.scala
type R = Record.`'i -> Int @@ CustomTag`.T
type RT = Record.`'b -> Boolean, 'i -> Int @@ CustomTag`.T
shapeless/core/jvm/src/test/scala/shapeless/serialization.scala
type R = Record.`'a -> Int, 'b -> String, 'c -> Boolean`.T
type U = Union.`'a -> Int, 'b -> String, 'c -> Boolean`.T
type RM = Record.`'c -> Boolean, 'd -> Double`.T
type U = Union.`'foo -> Int, 'bar -> String, 'baz -> Boolean`.T
Set("foo") -> Option("bar"),
Set(23) -> Option(13)
type R = Record.`'a -> Int, 'b -> String, 'c -> Boolean`.T
.recordLens[Record.`'foo -> Int, 'bar -> String, 'baz -> Boolean`.T]('bar)
shapeless/core/src/test/scala/shapeless/default.scala
assertTypedEquals[Record.`'s -> String, 'flagOpt -> Option[Boolean]`.T](
assertTypedEquals[Record.`'s -> String, 'flagOpt -> Option[Boolean]`.T](
shapeless/core/src/test/scala/shapeless/unions.scala
type U = Union.`'i -> Int, 's -> String, 'b -> Boolean`.T
typed[ii](Coproduct[Union.`'i -> Int`.T]('i ->> 23))
typed[iiss](Coproduct[Union.`'i -> Int, 's -> String`.T]('s ->> "foo"))
Coproduct[Union.`'i -> Int, 's -> String, 'b -> Boolean`.T]('b ->> true)
// typed[Union.`'i -> Int, 's -> String`.T](Inl('i ->> 23))
// val u: Union.`'i -> Int, 's -> String`.T = Inl('i ->> 23)
type U = Union.`'i -> Int`.T
type U = Union.`'i -> Int, 's -> String`.T
type U = Union.`'i -> Int, 's -> String, 'b -> Boolean`.T
type U = Union.`'i -> 2`.T
type U = Union.`'i -> 2, 's -> "a", 'b -> true`.T
type U = Union.`'i -> 2`.T
type U = Union.`'i -> 2, 's -> String, 'b -> true`.T
assertTypedEquals(Coproduct[UF]('i.narrow -> 23), f1)
assertTypedEquals(Coproduct[UF]('s.narrow -> "foo"), f2)
assertTypedEquals(Coproduct[UF]('b.narrow -> true), f3)
Union.`"first" -> Option[Int], "second" -> Option[Boolean], "third" -> Option[String]`.T
assertTypedEquals(Coproduct[USF]("first".narrow -> Option(2)), f1)
assertTypedEquals(Coproduct[USF]("second".narrow -> Option(true)), f2)
Coproduct[USF]("third".narrow -> Option.empty[String]),
assertTypedEquals(Map[Symbol, Any]('i -> 23), m1)
assertTypedEquals(Map[Symbol, Any]('s -> "foo"), m2)
assertTypedEquals(Map[Symbol, Any]('b -> true), m3)
assertTypedEquals(Map[Symbol, Any]('i -> 23), m1)
assertTypedEquals(Map[Symbol, Any]('s -> "foo"), m2)
assertTypedEquals(Map[Symbol, Any]('b -> true), m3)
Union.`"first" -> Option[Int], "second" -> Option[Boolean], "third" -> Option[String]`.T
assertTypedEquals(Map[String, Option[Any]]("first" -> Some(2)), m1)
assertTypedEquals(Map[String, Option[Any]]("second" -> Some(true)), m2)
Map[String, Option[Any]]("third" -> Option.empty[String]),
assertTypedEquals(Map[String, Option[Any]]("first" -> Some(2)), m1)
assertTypedEquals(Map[String, Option[Any]]("second" -> Some(true)), m2)
Map[String, Option[Any]]("third" -> Option.empty[String]),
type R = Union.`'i -> Boolean, 's -> String, 'b -> String`.T
type U = Union.`"foo" -> String, "bar" -> Boolean, "baz" -> Double`.T
type U = Union.`"foo" -> String, "bar" -> Boolean, "baz" -> Double`.T
shapeless/core/src/test/scala/shapeless/labelledgeneric.scala
Record.`'author -> String, 'title -> String, 'id -> Int, 'price -> Double`.T
Record.`'title -> String, 'id -> Int, 'authors -> Seq[String]`.T
type TreeUnion = Union.`'Leaf -> Leaf, 'Node -> Node`.T
type NonCCARec = Record.`'i -> Int, 's -> String`.T
type NonCCBRec = Record.`'b -> Boolean, 'd -> Double`.T
type AbsUnion = Union.`'NonCCA -> NonCCA, 'NonCCB -> NonCCB`.T
type NonCCRec = Record.`'i -> Int, 's -> String`.T
type LazyRec = Record.`'prev -> NonCCLazy, 'next -> NonCCLazy`.T
shapeless/core/src/test/scala/shapeless/product.scala
val fooL = foo.toRecord[Record.`'i -> AnyVal, 's -> String`.T]
val barL = bar.toRecord[Record.`'b -> Boolean, 'f -> Foo`.T]
val expected = Map('i.narrow -> 1, 's.narrow -> "b")
val expected = Map[Symbol, Any]('i -> 1, 's -> "b")
shapeless/core/src/test/scala/shapeless/records.scala
Record.`'stringVal -> String, 'intVal -> Int, 'boolVal -> Boolean`.T
val in = Map('intVal -> 4, 'stringVal -> "Blarr", 'boolVal -> true)
val in2 = Map('intVal -> 4, 'stringVal -> "Blarr")
intField1 -> 4,
stringField1 -> "Blarr",
boolField1 -> true,
doubleField1 -> 5.0
typed[Record.`'a -> Int, 'b -> String, 'c -> Boolean`.T](rm)
type R = Record.`'i -> Int, 's -> String, 'c -> Char, 'j -> Int`.T
type L = Record.`'c -> Char, 'j -> Int`.T
type A1 = Record.`'i -> Int, 's -> String`.T
typed[Record.`'i -> Int`.T]('i ->> 23 :: HNil)
typed[Record.`'i -> Int, 's -> String`.T]('i ->> 23 :: 's ->> "foo" :: HNil)
typed[Record.`'i -> Int, 's -> String, 'b -> Boolean`.T](
typed[Record.`'i -> 2`.T]('i ->> 2.narrow :: HNil)
typed[Record.`'i -> 2, 's -> "a", 'b -> true`.T](
illTyped(""" typed[Record.`'i -> 2`.T]('i ->> 3.narrow :: HNil) """)
typed[Record.`'i -> 2, 's -> String, 'b -> true`.T](
typed[Record.`'i -> Int, 's -> String, 'b -> Boolean`.T](r)
typed[Record.`'i -> Int, 's -> String, 'b -> Boolean`.T](r)
('i.narrow -> 23) :: ('s.narrow -> "foo") :: ('b.narrow -> true) :: HNil,
("first".narrow -> Some(2)) :: ("second".narrow -> Some(true)) :: ("third" -> Option
assertTypedEquals(Map[Symbol, Any]('i -> 23, 's -> "foo", 'b -> true), m)
assertTypedEquals(Map[Symbol, Any]('i -> 23, 's -> "foo", 'b -> true), m)
"first" -> Some(2),
"second" -> Some(true),
"third" -> Option.empty[String]
"first" -> Some(2),
"second" -> Some(true),
"third" -> Option.empty[String]
assertTypedEquals[Record.`'i -> Boolean, 's -> String, 'b -> String`.T](
val rt = Record.`'x -> Int, 'y -> String, 'z -> Boolean`
shapeless/core/src/test/scala/shapeless/coproduct.scala
type U = Union.`'i -> Int, 's -> String, 'b -> Boolean`.T
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment