public void testCharacterSimpleSplitWithNoDelimiter() { String simple = "a,b,c"; Iterable<String> letters = Splitter.on('.').split(simple); assertThat(letters).containsExactly("a,b,c").inOrder(); }
public static BitmapSubject assertThat(Bitmap bitmap) { return Truth.assertAbout(FACTORY).that(bitmap); }
/** * Given a factory for some {@code Subject} class, returns a builder whose {@code that(actual)} * method creates instances of that class. */ public static <S extends Subject<S, T>, T> SimpleSubjectBuilder<S, T> assertAbout( Subject.Factory<S, T> factory) { return assert_().about(factory); }
public void testLimitExtraSeparatorsTrim3() { String text = ",,a,, , b ,, c,d "; Iterable<String> items = COMMA_SPLITTER.limit(3).omitEmptyStrings().trimResults().split(text); assertThat(items).containsExactly("a", "b", "c,d").inOrder(); }
public void testMapSplitter_trimmedKeyValue() { Map<String, String> m = COMMA_SPLITTER .withKeyValueSeparator(Splitter.on(':').trimResults()) .split("boy : tom , girl: tina , cat : kitty , dog: tommy "); ImmutableMap<String, String> expected = ImmutableMap.of("boy", "tom", "girl", "tina", "cat", "kitty", "dog", "tommy"); assertThat(m).isEqualTo(expected); assertThat(m.entrySet()).containsExactlyElementsIn(expected.entrySet()).inOrder(); }
@GwtIncompatible // Splitter.onPattern public void testPatternSplitWithDoubleDelimiter() { String doubled = "a,,b,c"; Iterable<String> letters = Splitter.onPattern(",").split(doubled); assertThat(letters).containsExactly("a", "", "b", "c").inOrder(); }
@Test public void nonResizedRequestsAreTransformedWhenAlwaysTransformIsSet() { Request input = new Request.Builder(IMAGE_URI).build(); Request output = alwaysResizeTransformer.transformRequest(input); assertThat(output).isNotSameAs(input); assertThat(output.hasSize()).isFalse(); String expected = Thumbor.create(HOST).buildImage(IMAGE).toUrl(); assertThat(output.uri.toString()).isEqualTo(expected); }
@Test public void testInheritStyle() { style.inherit(createAncestorStyle()); assertWithMessage("id must not be inherited").that(style.getId()).isNull(); assertThat(style.isUnderline()).isTrue(); assertThat(style.isLinethrough()).isTrue(); assertThat(style.getStyle()).isEqualTo(STYLE_BOLD_ITALIC); assertThat(style.getFontFamily()).isEqualTo(FONT_FAMILY); assertThat(style.getFontColor()).isEqualTo(WHITE); assertWithMessage("do not inherit backgroundColor").that(style.hasBackgroundColor()).isFalse(); }
@Test public void testSelfLoop() { EndpointPair<String> unordered = EndpointPair.unordered("node", "node"); assertThat(unordered.isOrdered()).isFalse(); assertThat(unordered).containsExactly("node", "node"); assertThat(unordered.nodeU()).isEqualTo("node"); assertThat(unordered.nodeV()).isEqualTo("node"); assertThat(unordered.adjacentNode("node")).isEqualTo("node"); assertThat(unordered.toString()).isEqualTo("[node, node]"); }
@Test public void testHandleNulls() { mapCache.put("foo", "bar"); mapCache.put("non-null key", null); mapCache.put(null, "non-null value"); assertThat(mapCache.get("foo")).isEqualTo("bar"); assertThat(mapCache.get("non-null key")).isNull(); assertThat(mapCache.get(null)).isEqualTo("non-null value"); assertThat(mapCache.containsKey("foo")).isTrue(); assertThat(mapCache.containsKey("bar")).isFalse(); assertThat(mapCache.containsKey("non-null key")).isTrue(); assertThat(mapCache.containsKey(null)).isTrue(); // Test again - in reverse order. assertThat(mapCache.get(null)).isEqualTo("non-null value"); assertThat(mapCache.get("non-null key")).isNull(); assertThat(mapCache.get("foo")).isEqualTo("bar"); } }
@Test public void edgeOrder_natural() { MutableNetwork<Integer, String> network = NetworkBuilder.directed().edgeOrder(ElementOrder.<String>natural()).build(); addEdges(network); assertThat(network.edgeOrder()).isEqualTo(ElementOrder.sorted(Ordering.<String>natural())); assertThat(network.edges()).containsExactly("e", "i", "p").inOrder(); assertThat(network.nodeOrder()).isEqualTo(insertion()); // default }
public void testWildcardCaptured_typeVariableDeclaresTypeBound_wildcardHasNoExplicitUpperBound() throws Exception { TypeToken<Counter<?>> type = new TypeToken<Counter<?>>() {}; TypeToken<?> fieldType = type.resolveType(Counter.class.getDeclaredField("counts").getGenericType()); Type[] typeArgs = ((ParameterizedType) fieldType.getType()).getActualTypeArguments(); assertThat(typeArgs).asList().hasSize(1); TypeVariable<?> captured = (TypeVariable<?>) typeArgs[0]; assertThat(captured.getBounds()).asList().containsExactly(Number.class); assertThat(new TypeToken<List<? extends Number>>() {}.isSupertypeOf(fieldType)).isTrue(); assertThat(new TypeToken<List<? extends Iterable<?>>>() {}.isSupertypeOf(fieldType)).isFalse(); }
@GwtIncompatible // digs into internals of the non-GWT implementation public void testMaximumSize_largerThanInt() { CacheBuilder<Object, Object> builder = CacheBuilder.newBuilder().initialCapacity(512).maximumSize(Long.MAX_VALUE); LocalCache<?, ?> cache = ((LocalCache.LocalManualCache<?, ?>) builder.build()).localCache; assertThat(cache.segments.length * cache.segments[0].table.length()).isEqualTo(512); }
@Test public void testOrderedEndpointPair() { EndpointPair<String> ordered = EndpointPair.ordered("source", "target"); assertThat(ordered.isOrdered()).isTrue(); assertThat(ordered).containsExactly("source", "target").inOrder(); assertThat(ordered.source()).isEqualTo("source"); assertThat(ordered.target()).isEqualTo("target"); assertThat(ordered.nodeU()).isEqualTo("source"); assertThat(ordered.nodeV()).isEqualTo("target"); assertThat(ordered.adjacentNode("source")).isEqualTo("target"); assertThat(ordered.adjacentNode("target")).isEqualTo("source"); assertThat(ordered.toString()).isEqualTo("<source -> target>"); }
public void testCheckArgument_nullMessageWithArgs_failure() { try { Preconditions.checkArgument(false, null, "b", "d"); fail("no exception thrown"); } catch (IllegalArgumentException e) { assertThat(e).hasMessageThat().isEqualTo("null [b, d]"); } }
@Test public void duplicateFields() { // Duplicate fields are allowed - some SQL queries produce this type of value. Struct struct = Struct.newBuilder().set("").to("x").set("").to(Value.int64(2)).build(); assertThat(struct.getType()) .isEqualTo( Type.struct( Type.StructField.of("", Type.string()), Type.StructField.of("", Type.int64()))); assertThat(struct.isNull(0)).isFalse(); assertThat(struct.isNull(1)).isFalse(); assertThat(struct.getString(0)).isEqualTo("x"); assertThat(struct.getLong(1)).isEqualTo(2); }
@Test public void removeEdge_existingSelfLoopEdge() { addEdge(N1, N1, E11); assertThat(network.removeEdge(E11)).isTrue(); assertThat(network.edges()).doesNotContain(E11); assertThat(network.edgesConnecting(N1, N1)).isEmpty(); } }
@Test public void bindString() { Struct row = execute(Statement.newBuilder("SELECT @v").bind("v").to("abc"), Type.string()); assertThat(row.isNull(0)).isFalse(); assertThat(row.getString(0)).isEqualTo("abc"); }
public void testConcat_refStream_closeIsPropagated_Stream_concat() { // Just to demonstrate behavior of Stream::concat in the standard library AtomicInteger closeCountB = new AtomicInteger(0); Stream<String> streamB = Stream.of("b").onClose(closeCountB::incrementAndGet); Stream<String> concatenated = Stream.<Stream<String>>of(Stream.of("a"), streamB, Stream.empty(), Stream.of("c", "d")) .reduce(Stream.empty(), Stream::concat); assertThat(concatenated).containsExactly("a", "b", "c", "d").inOrder(); concatenated.close(); Truth.assertThat(closeCountB.get()).isEqualTo(1); }
@Test public void struct() { Struct struct = Struct.newBuilder().set("f1").to("v1").set("f2").to(30).build(); Value v1 = Value.struct(struct); assertThat(v1.getType()).isEqualTo(struct.getType()); assertThat(v1.isNull()).isFalse(); assertThat(v1.getStruct()).isEqualTo(struct); assertThat(v1.toString()).isEqualTo("[v1, 30]"); Value v2 = Value.struct(struct.getType(), struct); assertThat(v2).isEqualTo(v1); expectedException.expect(IllegalArgumentException.class); expectedException.expectMessage("Mismatch between struct value and type."); Value.struct(Type.struct(Arrays.asList(StructField.of("f3", Type.string()))), struct); }