示例#1
0
  @Test
  public void shouldAllowArraysOfMapsToBeAddedToTheMapWithAndMaps() throws Exception {
    // Given
    MapBuilder<String, Integer> mapBuilder = mapBuilder();

    Map<String, Integer> map = new HashMap<String, Integer>();
    map.put("five", 5);
    map.put("ten", 10);

    Map<String, Integer> secondMap = new HashMap<String, Integer>();
    secondMap.put("fifteen", 15);

    Map<String, Integer> thirdMap = new HashMap<String, Integer>();
    thirdMap.put("twenty", 20);

    @SuppressWarnings("unchecked")
    Map<String, Integer>[] mapArray = new Map[] {secondMap, thirdMap};

    Map<String, Integer> expectedMap = new HashMap<String, Integer>();
    expectedMap.put("five", 5);
    expectedMap.put("ten", 10);
    expectedMap.put("fifteen", 15);
    expectedMap.put("twenty", 20);

    // When
    Map<String, Integer> actualMap = mapBuilder.with(map).andMaps(mapArray).build();

    // Then
    assertThat(actualMap, is(expectedMap));
  }
示例#2
0
  @Test
  public void shouldAllowIterablesOfMapsToBeAddedToTheMapWithAndMaps() throws Exception {
    // Given
    MapBuilder<String, Integer> mapBuilder = mapBuilder();

    Map<String, Integer> firstMap = new HashMap<String, Integer>();
    firstMap.put("third", 3);
    firstMap.put("fourth", 4);

    Map<String, Integer> secondMap = new HashMap<String, Integer>();
    firstMap.put("fifth", 5);

    Iterable<Map<String, Integer>> maps = iterableWith(firstMap, secondMap);

    Map<String, Integer> expectedMap = new HashMap<String, Integer>();
    expectedMap.put("first", 1);
    expectedMap.put("second", 2);
    expectedMap.put("third", 3);
    expectedMap.put("fourth", 4);
    expectedMap.put("fifth", 5);

    // When
    Map<String, Integer> actualMap =
        mapBuilder.withKeyValuePairs("first", 1, "second", 2).andMaps(maps).build();

    // Then
    assertThat(actualMap, is(expectedMap));
  }
示例#3
0
  @Test
  public void shouldAllowArraysOfMapEntryInstancesToBeAddedToTheMapWithWithEntries()
      throws Exception {
    // Given
    Map<String, Integer> expectedMap = new HashMap<String, Integer>();
    expectedMap.put("five", 5);
    expectedMap.put("ten", 10);
    expectedMap.put("fifteen", 15);
    expectedMap.put("twenty", 20);
    @SuppressWarnings("unchecked")
    Map.Entry<String, Integer>[] firstMapEntryArray =
        new Map.Entry[] {mapEntryFor("five", 5), mapEntryFor("ten", 10)};
    @SuppressWarnings("unchecked")
    Map.Entry<String, Integer>[] secondMapEntryArray =
        new Map.Entry[] {mapEntryFor("fifteen", 15), mapEntryFor("twenty", 20)};

    // When
    Map<String, Integer> actualMap =
        mapBuilder(String.class, Integer.class)
            .withEntries(firstMapEntryArray)
            .withEntries(secondMapEntryArray)
            .build();

    // Then
    assertThat(actualMap, is(expectedMap));
  }
示例#4
0
  @Test
  public void shouldAllowMapsToBeAddedToTheMapWithAndMaps() throws Exception {
    // Given
    MapBuilder<String, Integer> mapBuilder = mapBuilder();

    Map<String, Integer> firstMap = new HashMap<String, Integer>();
    firstMap.put("second", 2);

    Map<String, Integer> secondMap = new HashMap<String, Integer>();
    secondMap.put("third", 3);
    secondMap.put("fourth", 4);

    Map<String, Integer> expected = new HashMap<String, Integer>();
    expected.put("first", 1);
    expected.put("second", 2);
    expected.put("third", 3);
    expected.put("fourth", 4);

    // When
    Map<String, Integer> actual =
        mapBuilder.with(tuple("first", 1)).and(firstMap, secondMap).build();

    // Then
    assertThat(actual, is(expected));
  }
示例#5
0
  @Test
  public void shouldAllowTuplesToBeAddedToTheMapWithWithPairs() throws Exception {
    // Given
    MapBuilder<String, Integer> mapBuilder = mapBuilder();
    Map<String, Integer> expected = new HashMap<String, Integer>();
    expected.put("first", 1);
    expected.put("second", 2);
    expected.put("third", 3);

    // When
    Map<String, Integer> actual =
        mapBuilder.with(tuple("first", 1)).with(tuple("second", 2), tuple("third", 3)).build();

    // Then
    assertThat(actual, is(expected));
  }
示例#6
0
  @Test
  public void shouldAllowIterablesOfTuplesToBeAddedToTheMapWithWithPairs() throws Exception {
    // Given
    MapBuilder<String, Integer> mapBuilder = mapBuilder();
    Map<String, Integer> expectedMap = new HashMap<String, Integer>();
    expectedMap.put("one", 1);
    expectedMap.put("two", 2);
    expectedMap.put("three", 3);
    expectedMap.put("four", 4);
    Iterable<Pair<String, Integer>> firstInputIterable = listWith(tuple("one", 1), tuple("two", 2));
    Iterable<Pair<String, Integer>> secondInputIterable =
        listWith(tuple("three", 3), tuple("four", 4));

    // When
    Map<String, Integer> actualMap =
        mapBuilder.withPairs(firstInputIterable).withPairs(secondInputIterable).build();

    // Then
    assertThat(actualMap, is(expectedMap));
  }
示例#7
0
  @Test
  public void shouldAllowMapEntryInstancesToBeAddedToTheMapWithAndEntries() {
    // Given
    MapBuilder<String, Integer> mapBuilder = mapBuilder();
    Map<String, Integer> expectedMap = new HashMap<String, Integer>();
    expectedMap.put("five", 5);
    expectedMap.put("ten", 10);
    expectedMap.put("fifteen", 15);
    expectedMap.put("twenty", 20);

    // When
    Map<String, Integer> actualMap =
        mapBuilder
            .with(mapEntryFor("five", 5))
            .and(mapEntryFor("ten", 10), mapEntryFor("fifteen", 15))
            .and(mapEntryFor("twenty", 20))
            .build();

    // Then
    assertThat(actualMap, is(expectedMap));
  }
示例#8
0
  @Test
  public void shouldAllowKeysAndValuesToBeAddedToTheMapWithAndKeyValuePairs() throws Exception {
    // Given
    MapBuilder<String, Integer> mapBuilder = mapBuilder();
    Map<String, Integer> expected = new HashMap<String, Integer>();
    expected.put("zeroth", 0);
    expected.put("first", 1);
    expected.put("second", 2);
    expected.put("third", 3);

    // When
    Map<String, Integer> actual =
        mapBuilder
            .withKeyValuePair("zeroth", 0)
            .andKeyValuePairs("first", 1, "second", 2)
            .andKeyValuePair("third", 3)
            .build();

    // Then
    assertThat(actual, is(expected));
  }
示例#9
0
  @Test
  public void shouldAllowIterablesOfTuplesToBeAddedToTheMapWithAndPairs() throws Exception {
    // Given
    MapBuilder<String, Integer> mapBuilder = mapBuilder();
    Map<String, Integer> expectedMap = new HashMap<String, Integer>();
    expectedMap.put("first", 1);
    expectedMap.put("second", 2);
    expectedMap.put("third", 3);
    expectedMap.put("fourth", 4);

    Iterable<Pair<String, Integer>> iterableOfTuples =
        listWith(tuple("third", 3), tuple("fourth", 4));

    // When
    Map<String, Integer> actualMap =
        mapBuilder
            .with(mapEntryFor("first", 1), mapEntryFor("second", 2))
            .andPairs(iterableOfTuples)
            .build();

    // Then
    assertThat(actualMap, is(expectedMap));
  }
示例#10
0
  @Test
  public void shouldAllowArraysOfTuplesToBeAddedToTheMapWithAndPairs() throws Exception {
    // Given
    MapBuilder<String, Integer> mapBuilder = mapBuilder();
    Map<String, Integer> expectedMap = new HashMap<String, Integer>();
    expectedMap.put("five", 5);
    expectedMap.put("ten", 10);
    expectedMap.put("fifteen", 15);
    expectedMap.put("twenty", 20);

    @SuppressWarnings("unchecked")
    Pair<String, Integer>[] tupleArray = new Pair[] {tuple("fifteen", 15), tuple("twenty", 20)};

    // When
    Map<String, Integer> actualMap =
        mapBuilder
            .with(mapEntryFor("five", 5), mapEntryFor("ten", 10))
            .andPairs(tupleArray)
            .build();

    // Then
    assertThat(actualMap, is(expectedMap));
  }
示例#11
0
  @Test
  public void shouldAllowIterablesOfMapEntryInstancesToBeAddedToTheMapWithAndEntries()
      throws Exception {
    // Given
    MapBuilder<String, Integer> mapBuilder = mapBuilder();
    Map<String, Integer> expectedMap = new HashMap<String, Integer>();
    expectedMap.put("first", 1);
    expectedMap.put("second", 2);
    expectedMap.put("third", 3);
    expectedMap.put("fourth", 4);

    Iterable<Map.Entry<String, Integer>> someOtherElements =
        listWith(mapEntryFor("third", 3), mapEntryFor("fourth", 4));

    // When
    Map<String, Integer> actualMap =
        mapBuilder
            .with(mapEntryFor("first", 1), mapEntryFor("second", 2))
            .andEntries(someOtherElements)
            .build();

    // Then
    assertThat(actualMap, is(expectedMap));
  }
示例#12
0
  @Test
  public void shouldAllowArraysOfTuplesToBeAddedToTheMapWithWithPairs() throws Exception {
    // Given
    Map<String, Integer> expectedMap = new HashMap<String, Integer>();
    expectedMap.put("five", 5);
    expectedMap.put("ten", 10);
    expectedMap.put("fifteen", 15);
    expectedMap.put("twenty", 20);
    @SuppressWarnings("unchecked")
    Pair<String, Integer>[] firstTupleArray = new Pair[] {tuple("five", 5), tuple("ten", 10)};
    @SuppressWarnings("unchecked")
    Pair<String, Integer>[] secondTupleArray =
        new Pair[] {tuple("fifteen", 15), tuple("twenty", 20)};

    // When
    Map<String, Integer> actualMap =
        mapBuilder(String.class, Integer.class)
            .withPairs(firstTupleArray)
            .withPairs(secondTupleArray)
            .build();

    // Then
    assertThat(actualMap, is(expectedMap));
  }