Java 类org.apache.commons.collections4.BidiMap 实例源码

@Test(timeout = 1000)
public void testBidiClear() {
    fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testBidiClear");
    if (!(isRemoveSupported())) {
        try {
            makeFullMap().clear();
            makeFullMap().clear();
        } catch (final UnsupportedOperationException ex) {
        }
        return ;
    } 
    BidiMap<?, ?> map = makeFullMap();
    map.clear();
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4857,map,4856,map.isEmpty());
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4859,map.inverseBidiMap(),4858,map.inverseBidiMap().isEmpty());
    map = makeFullMap().inverseBidiMap();
    map.clear();
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4861,map,4860,map.isEmpty());
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4863,map.inverseBidiMap(),4862,map.inverseBidiMap().isEmpty());
    fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
}

@Test(timeout = 1000)
public void testBidiClear_add1568() {
    fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testBidiClear_add1568");
    if (!(isRemoveSupported())) {
        try {
            makeFullMap().clear();
        } catch (final UnsupportedOperationException ex) {
        }
        return ;
    } 
    BidiMap<?, ?> map = makeFullMap();
    map.clear();
    map.clear();
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4857,map,4856,map.isEmpty());
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4859,map.inverseBidiMap(),4858,map.inverseBidiMap().isEmpty());
    map = makeFullMap().inverseBidiMap();
    map.clear();
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4861,map,4860,map.isEmpty());
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4863,map.inverseBidiMap(),4862,map.inverseBidiMap().isEmpty());
    fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
}

@Test(timeout = 1000)
public void testBidiClear_add1569() {
    fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testBidiClear_add1569");
    if (!(isRemoveSupported())) {
        try {
            makeFullMap().clear();
        } catch (final UnsupportedOperationException ex) {
        }
        return ;
    } 
    BidiMap<?, ?> map = makeFullMap();
    map.clear();
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4857,map,4856,map.isEmpty());
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4859,map.inverseBidiMap(),4858,map.inverseBidiMap().isEmpty());
    map = makeFullMap().inverseBidiMap();
    map.clear();
    map.clear();
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4861,map,4860,map.isEmpty());
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4863,map.inverseBidiMap(),4862,map.inverseBidiMap().isEmpty());
    fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
}

@Test(timeout = 1000)
public void testBidiClear_remove1189() {
    fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testBidiClear_remove1189");
    if (!(isRemoveSupported())) {
        try {
            makeFullMap().clear();
        } catch (final UnsupportedOperationException ex) {
        }
        return ;
    } 
    BidiMap<?, ?> map = makeFullMap();
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4857,map,4856,map.isEmpty());
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4859,map.inverseBidiMap(),4858,map.inverseBidiMap().isEmpty());
    map = makeFullMap().inverseBidiMap();
    map.clear();
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4861,map,4860,map.isEmpty());
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4863,map.inverseBidiMap(),4862,map.inverseBidiMap().isEmpty());
    fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
}

@Test(timeout = 1000)
public void testBidiClear_remove1190() {
    fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testBidiClear_remove1190");
    if (!(isRemoveSupported())) {
        try {
            makeFullMap().clear();
        } catch (final UnsupportedOperationException ex) {
        }
        return ;
    } 
    BidiMap<?, ?> map = makeFullMap();
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4857,map,4856,map.isEmpty());
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4859,map.inverseBidiMap(),4858,map.inverseBidiMap().isEmpty());
    map = makeFullMap().inverseBidiMap();
    map.clear();
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4861,map,4860,map.isEmpty());
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4863,map.inverseBidiMap(),4862,map.inverseBidiMap().isEmpty());
    fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
}

private synchronized Map.Entry<Follower, Future<Message>> startFollowingActually(
        final MidDeliveryMessageCondition<LogWatch> condition) {
    if (this.isStopped()) {
        throw new IllegalStateException("Cannot start following on an already terminated LogWatch.");
    }
    // assemble list of consumers to be handing down and then the follower
    final List<Pair<String, MessageMeasure<? extends Number, Follower>>> pairs = new ArrayList<>();
    for (final BidiMap.Entry<String, MessageMeasure<? extends Number, Follower>> entry : this.handingDown
            .entrySet()) {
        pairs.add(ImmutablePair.of(entry.getKey(),
                entry.getValue()));
    }
    // register the follower
    final Follower follower = new DefaultFollower(this, pairs);
    final Future<Message> expectation = condition == null ? null : follower.expect(condition);
    this.consumers.registerConsumer(follower);
    this.storage.followerStarted(follower);
    DefaultLogWatch.LOGGER.info("Registered {} for {}.", follower, this);
    return ImmutablePair.of(follower, expectation);
}

private static BidiMap<State, State> construct(TransitionSystem lts1, TransitionSystem lts2, boolean checkLabels) {
    // Check trivial case
    if (lts1.getNodes().size() != lts2.getNodes().size()) {
        return new DualHashBidiMap<>();
    }

    if (checkLabels) {
        boolean precond1 = checkPreconditions(lts1);
        boolean precond2 = checkPreconditions(lts2);
        if (precond1 != precond2)
            // Not isomorphic
            return new DualHashBidiMap<>();

        if (precond1 && precond2)
            // Both lts are totally reachable and deterministic. We can apply a special algorithm.
            return checkViaDepthSearch(lts1, lts2);
    }

    return new IsomorphismLogicComplex(lts1, lts2, checkLabels).getIsomorphism();
}

@Override
public synchronized BidiMap<V, K> inverseBidiMap() {
    if (inverse == null) {
        inverse = new UnmodifiableBidiMap<V, K>(decorated().inverseBidiMap());
        inverse.inverse = this;
    }
    return inverse;
}

@Override
public BidiMap<V, K> inverseBidiMap() {
    if (inverseBidiMap == null) {
        inverseBidiMap = createBidiMap(reverseMap, normalMap, this);
    }
    return inverseBidiMap;
}

@Override
public synchronized BidiMap<V, K> inverseBidiMap() {
    if (inverse == null) {
        inverse = new UnmodifiableBidiMap<V, K>(decorated().inverseBidiMap());
        inverse.inverse = this;
    }
    return inverse;
}

@Override
public BidiMap<V, K> inverseBidiMap() {
    if (inverseBidiMap == null) {
        inverseBidiMap = createBidiMap(reverseMap, normalMap, this);
    }
    return inverseBidiMap;
}

private String encodeInternal(String message, BidiMap<Character, Character> substitutionAlphabet) {
    StringBuilder result = new StringBuilder();
    for (char c : message.toCharArray()) {
        Character res = substitutionAlphabet.get(c);
        if (res == null)
            result.append(c);
        else {
            result.append(res);
        }
    }
    return result.toString();
}

/**
 * Generates map of substitution symbols for given language and substitution array
 *
 * @param language      language to generate substitution for
 * @param substitutions array of substitution characters
 * @return bi-directional map with 1:1 alphabets for given language
 */
public static BidiMap<Character, Character> generateSubstitutionAlphabet(Language language, char[] substitutions) {
    char[] languageAlphabet = getAlphabet(language);
    if (!ArrayUtils.isSameLength(substitutions, languageAlphabet))
        throw new IllegalArgumentException("Substitution array should have same alphabets as given language has");
    BidiMap<Character, Character> substitutionAlphabet = new DualHashBidiMap<>();
    for (int i = 0; i < languageAlphabet.length; i++) {
        char key = languageAlphabet[i];
        char value = substitutions[i];
        substitutionAlphabet.put(key, value);
    }
    return substitutionAlphabet;
}

public static void main(String[] args) {
    String[] englishWords = {"one", "two", "three","ball","snow"};
    String[] russianWords = {"jeden", "dwa", "trzy", "kula", "snieg"};

    // Create Multiset
    BidiMap<String, String> biMap = new DualHashBidiMap();
    // Create Polish-English dictionary
    int i = 0;
    for(String englishWord: englishWords) {
        biMap.put(englishWord, russianWords[i]);
        i++;
    }

    // Print count words
    System.out.println(biMap); // Print "{ball=kula, snow=snieg, one=jeden, two=dwa, three=trzy}" - in random orders
    // Print unique words
    System.out.println(biMap.keySet());    // print "[ball, snow, one, two, three]"- in random orders
    System.out.println(biMap.values());    // print "[kula, snieg, jeden, dwa, trzy]" - in random orders

    // Print translate by words
    System.out.println("one = " + biMap.get("one"));    // print one = jeden
    System.out.println("two = " + biMap.get("two"));    // print two = dwa
    System.out.println("kula = " + biMap.getKey("kula"));    // print kula = ball
    System.out.println("snieg = " + biMap.getKey("snieg"));    // print snieg = snow
    System.out.println("empty = " + biMap.get("empty"));    // print empty = null

    // Print count word's pair
    System.out.println(biMap.size());    //print 5

}

public static void main(String[] args) {
    String[] englishWords = {"one", "two", "three","ball","snow"};
    String[] russianWords = {"jeden", "dwa", "trzy", "kula", "snieg"};

    // Создаем Multiset
    BidiMap<String, String> biMap = new DualHashBidiMap();
    // создаем англо-польский словарь
    int i = 0;
    for(String englishWord: englishWords) {
        biMap.put(englishWord, russianWords[i]);
        i++;
    }

    // Выводим кол-вом вхождений слов
    System.out.println(biMap); // напечатает {ball=kula, snow=snieg, one=jeden, two=dwa, three=trzy}- в произвольном порядке
    // Выводим все уникальные слова
    System.out.println(biMap.keySet());    // напечатает [ball, snow, one, two, three]- в произвольном порядке
    System.out.println(biMap.values());    // напечатает [kula, snieg, jeden, dwa, trzy]- в произвольном порядке

    // Выводим перевод по каждому слову
    System.out.println("one = " + biMap.get("one"));    // напечатает one = jeden
    System.out.println("two = " + biMap.get("two"));    // напечатает two = dwa
    System.out.println("kula = " + biMap.getKey("kula"));    // напечатает kula = ball
    System.out.println("snieg = " + biMap.getKey("snieg"));    // напечатает snieg = snow
    System.out.println("empty = " + biMap.get("empty"));    // напечатает empty = null

    // Выводим общее количество переводов в словаре
    System.out.println(biMap.size());    //напечатает 5

}

/**
 * Encode string.
 *
 * @param original
 *     the original
 * @return the string
 */
protected String encode(String original) {
  BidiMap<String, String> codec = CODEC.get();
  String key = codec.getKey(original);
  if (key == null) {
    key = Integer.toHexString(codec.size());
    codec.put(key, original);
  }
  return key;
}

/**
 *
 *
 * @return
 */
public BidiMap<String, String> getGUILanguageStrings() {
  final BidiMap<String, String> langs = new DualHashBidiMap<String, String>();
  final String[] langsFromProp = getProp(AVAILABLE_LOCALES).split(";");
  for (String st : langsFromProp) {
    final String[] parts = st.split("-");
    langs.put(parts[0], parts[1]);
  }
  return langs;
}

public void testDecorateFactory() {
    fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDecorateFactory");
    final BidiMap<K, V> map = makeFullMap();
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5549,map);
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5551,null,5550,org.apache.commons.collections4.bidimap.UnmodifiableBidiMap.unmodifiableBidiMap(map));
    try {
        org.apache.commons.collections4.bidimap.UnmodifiableBidiMap.unmodifiableBidiMap(null);
    } catch (final IllegalArgumentException ex) {
    }
    fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
}

@org.junit.Test(timeout = 1000)
public void testDecorateFactory_add1651() {
    fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testDecorateFactory_add1651");
    final BidiMap<K, V> map = makeFullMap();
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5549,map);
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),5551,null,5550,org.apache.commons.collections4.bidimap.UnmodifiableBidiMap.unmodifiableBidiMap(map));
    try {
        org.apache.commons.collections4.bidimap.UnmodifiableBidiMap.unmodifiableBidiMap(null);
        org.apache.commons.collections4.bidimap.UnmodifiableBidiMap.unmodifiableBidiMap(null);
    } catch (final IllegalArgumentException ex) {
    }
    fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
}

@SuppressWarnings(value = "unchecked")
@Test(timeout = 1000)
public void testBidiPut_add1592() {
    fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testBidiPut_add1592");
    if ((!(isPutAddSupported())) || (!(isPutChangeSupported()))) {
        return ;
    } 
    final BidiMap<K, V> map = makeObject();
    final BidiMap<V, K> inverse = map.inverseBidiMap();
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4936,map,4935,map.size());
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),487,map,486,map.size());
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4938,inverse,4937,inverse.size());
    map.put(((K)("A")), ((V)("B")));
    map.put(((K)("A")), ((V)("B")));
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4940,map,4939,map.size());
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4942,map,4941,map.size());
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4944,inverse,4943,inverse.size());
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4946,map,4945,map.get("A"));
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4948,inverse,4947,inverse.get("B"));
    map.put(((K)("A")), ((V)("C")));
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4950,map,4949,map.size());
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),1952,map,1951,map.size());
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4952,inverse,4951,inverse.size());
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4954,map,4953,map.get("A"));
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4956,inverse,4955,inverse.get("C"));
    map.put(((K)("B")), ((V)("C")));
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),386,map,385,map.size());
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),1802,map,1801,map.size());
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4958,inverse,4957,inverse.size());
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4960,map,4959,map.get("B"));
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4962,inverse,4961,inverse.get("C"));
    map.put(((K)("E")), ((V)("F")));
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4964,map,4963,map.size());
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4966,map,4965,map.size());
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4968,inverse,4967,inverse.size());
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4970,map,4969,map.get("E"));
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4972,inverse,4971,inverse.get("F"));
    fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
}

@SuppressWarnings(value = "unchecked")
@Test(timeout = 1000)
public void testBidiPut_add1593() {
    fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testBidiPut_add1593");
    if ((!(isPutAddSupported())) || (!(isPutChangeSupported()))) {
        return ;
    } 
    final BidiMap<K, V> map = makeObject();
    final BidiMap<V, K> inverse = map.inverseBidiMap();
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4936,map,4935,map.size());
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),487,map,486,map.size());
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4938,inverse,4937,inverse.size());
    map.put(((K)("A")), ((V)("B")));
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4940,map,4939,map.size());
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4942,map,4941,map.size());
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4944,inverse,4943,inverse.size());
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4946,map,4945,map.get("A"));
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4948,inverse,4947,inverse.get("B"));
    map.put(((K)("A")), ((V)("C")));
    map.put(((K)("A")), ((V)("C")));
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4950,map,4949,map.size());
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),1952,map,1951,map.size());
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4952,inverse,4951,inverse.size());
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4954,map,4953,map.get("A"));
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4956,inverse,4955,inverse.get("C"));
    map.put(((K)("B")), ((V)("C")));
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),386,map,385,map.size());
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),1802,map,1801,map.size());
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4958,inverse,4957,inverse.size());
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4960,map,4959,map.get("B"));
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4962,inverse,4961,inverse.get("C"));
    map.put(((K)("E")), ((V)("F")));
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4964,map,4963,map.size());
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4966,map,4965,map.size());
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4968,inverse,4967,inverse.size());
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4970,map,4969,map.get("E"));
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4972,inverse,4971,inverse.get("F"));
    fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
}

@SuppressWarnings(value = "unchecked")
@Test(timeout = 1000)
public void testBidiPut_add1594() {
    fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testBidiPut_add1594");
    if ((!(isPutAddSupported())) || (!(isPutChangeSupported()))) {
        return ;
    } 
    final BidiMap<K, V> map = makeObject();
    final BidiMap<V, K> inverse = map.inverseBidiMap();
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4936,map,4935,map.size());
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),487,map,486,map.size());
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4938,inverse,4937,inverse.size());
    map.put(((K)("A")), ((V)("B")));
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4940,map,4939,map.size());
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4942,map,4941,map.size());
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4944,inverse,4943,inverse.size());
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4946,map,4945,map.get("A"));
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4948,inverse,4947,inverse.get("B"));
    map.put(((K)("A")), ((V)("C")));
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4950,map,4949,map.size());
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),1952,map,1951,map.size());
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4952,inverse,4951,inverse.size());
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4954,map,4953,map.get("A"));
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4956,inverse,4955,inverse.get("C"));
    map.put(((K)("B")), ((V)("C")));
    map.put(((K)("B")), ((V)("C")));
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),386,map,385,map.size());
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),1802,map,1801,map.size());
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4958,inverse,4957,inverse.size());
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4960,map,4959,map.get("B"));
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4962,inverse,4961,inverse.get("C"));
    map.put(((K)("E")), ((V)("F")));
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4964,map,4963,map.size());
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4966,map,4965,map.size());
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4968,inverse,4967,inverse.size());
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4970,map,4969,map.get("E"));
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4972,inverse,4971,inverse.get("F"));
    fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
}

@SuppressWarnings(value = "unchecked")
@Test(timeout = 1000)
public void testBidiPut_add1595() {
    fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testBidiPut_add1595");
    if ((!(isPutAddSupported())) || (!(isPutChangeSupported()))) {
        return ;
    } 
    final BidiMap<K, V> map = makeObject();
    final BidiMap<V, K> inverse = map.inverseBidiMap();
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4936,map,4935,map.size());
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),487,map,486,map.size());
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4938,inverse,4937,inverse.size());
    map.put(((K)("A")), ((V)("B")));
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4940,map,4939,map.size());
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4942,map,4941,map.size());
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4944,inverse,4943,inverse.size());
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4946,map,4945,map.get("A"));
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4948,inverse,4947,inverse.get("B"));
    map.put(((K)("A")), ((V)("C")));
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4950,map,4949,map.size());
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),1952,map,1951,map.size());
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4952,inverse,4951,inverse.size());
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4954,map,4953,map.get("A"));
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4956,inverse,4955,inverse.get("C"));
    map.put(((K)("B")), ((V)("C")));
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),386,map,385,map.size());
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),1802,map,1801,map.size());
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4958,inverse,4957,inverse.size());
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4960,map,4959,map.get("B"));
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4962,inverse,4961,inverse.get("C"));
    map.put(((K)("E")), ((V)("F")));
    map.put(((K)("E")), ((V)("F")));
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4964,map,4963,map.size());
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4966,map,4965,map.size());
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4968,inverse,4967,inverse.size());
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4970,map,4969,map.get("E"));
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4972,inverse,4971,inverse.get("F"));
    fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
}

@SuppressWarnings(value = "unchecked")
public void testBidiPut() {
    fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testBidiPut");
    if ((!(isPutAddSupported())) || (!(isPutChangeSupported()))) {
        return ;
    } 
    final BidiMap<K, V> map = makeObject();
    final BidiMap<V, K> inverse = map.inverseBidiMap();
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4936,map,4935,map.size());
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),487,map,486,map.size());
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4938,inverse,4937,inverse.size());
    map.put(((K)("A")), ((V)("B")));
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4940,map,4939,map.size());
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4942,map,4941,map.size());
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4944,inverse,4943,inverse.size());
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4946,map,4945,map.get("A"));
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4948,inverse,4947,inverse.get("B"));
    map.put(((K)("A")), ((V)("C")));
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4950,map,4949,map.size());
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),1952,map,1951,map.size());
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4952,inverse,4951,inverse.size());
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4954,map,4953,map.get("A"));
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4956,inverse,4955,inverse.get("C"));
    map.put(((K)("B")), ((V)("C")));
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),386,map,385,map.size());
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),1802,map,1801,map.size());
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4958,inverse,4957,inverse.size());
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4960,map,4959,map.get("B"));
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4962,inverse,4961,inverse.get("C"));
    map.put(((K)("E")), ((V)("F")));
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4964,map,4963,map.size());
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4966,map,4965,map.size());
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4968,inverse,4967,inverse.size());
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4970,map,4969,map.get("E"));
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4972,inverse,4971,inverse.get("F"));
    fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
}

@SuppressWarnings(value = "unchecked")
public void testBidiPut_literalMutation1389() {
    fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testBidiPut_literalMutation1389");
    if ((!(isPutAddSupported())) || (!(isPutChangeSupported()))) {
        return ;
    } 
    final BidiMap<K, V> map = makeObject();
    final BidiMap<V, K> inverse = map.inverseBidiMap();
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4936,map,4935,map.size());
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),487,map,486,map.size());
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4938,inverse,4937,inverse.size());
    map.put(((K)("foo")), ((V)("B")));
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4940,map,4939,map.size());
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4942,map,4941,map.size());
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4944,inverse,4943,inverse.size());
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4946,map,4945,map.get("A"));
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4948,inverse,4947,inverse.get("B"));
    map.put(((K)("A")), ((V)("C")));
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4950,map,4949,map.size());
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),1952,map,1951,map.size());
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4952,inverse,4951,inverse.size());
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4954,map,4953,map.get("A"));
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4956,inverse,4955,inverse.get("C"));
    map.put(((K)("B")), ((V)("C")));
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),386,map,385,map.size());
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),1802,map,1801,map.size());
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4958,inverse,4957,inverse.size());
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4960,map,4959,map.get("B"));
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4962,inverse,4961,inverse.get("C"));
    map.put(((K)("E")), ((V)("F")));
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4964,map,4963,map.size());
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4966,map,4965,map.size());
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4968,inverse,4967,inverse.size());
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4970,map,4969,map.get("E"));
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4972,inverse,4971,inverse.get("F"));
    fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
}

@SuppressWarnings(value = "unchecked")
public void testBidiPut_literalMutation1390() {
    fr.inria.diversify.testamplification.logger.Logger.writeTestStart(Thread.currentThread(),this, "testBidiPut_literalMutation1390");
    if ((!(isPutAddSupported())) || (!(isPutChangeSupported()))) {
        return ;
    } 
    final BidiMap<K, V> map = makeObject();
    final BidiMap<V, K> inverse = map.inverseBidiMap();
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4936,map,4935,map.size());
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),487,map,486,map.size());
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4938,inverse,4937,inverse.size());
    map.put(((K)("A")), ((V)("foo")));
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4940,map,4939,map.size());
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4942,map,4941,map.size());
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4944,inverse,4943,inverse.size());
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4946,map,4945,map.get("A"));
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4948,inverse,4947,inverse.get("B"));
    map.put(((K)("A")), ((V)("C")));
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4950,map,4949,map.size());
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),1952,map,1951,map.size());
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4952,inverse,4951,inverse.size());
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4954,map,4953,map.get("A"));
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4956,inverse,4955,inverse.get("C"));
    map.put(((K)("B")), ((V)("C")));
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),386,map,385,map.size());
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),1802,map,1801,map.size());
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4958,inverse,4957,inverse.size());
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4960,map,4959,map.get("B"));
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4962,inverse,4961,inverse.get("C"));
    map.put(((K)("E")), ((V)("F")));
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4964,map,4963,map.size());
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4966,map,4965,map.size());
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4968,inverse,4967,inverse.size());
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4970,map,4969,map.get("E"));
    fr.inria.diversify.testamplification.logger.Logger.logAssertArgument(Thread.currentThread(),4972,inverse,4971,inverse.get("F"));
    fr.inria.diversify.testamplification.logger.Logger.writeTestFinish(Thread.currentThread());
}