@Spy
    private DefaultToolchainsXmlFactory toolchainsXmlFactory;

    @InjectMocks
    private DefaultToolchainsBuilder toolchainBuilder;

    @BeforeEach
    void onSetup() {
        // MockitoAnnotations.openMocks(this);

        Map<String, String> envVarMap = new HashMap<>();
        envVarMap.put("testKey", "testValue");

   * @param c the character to test
   */
  public static void assertUnescaped(CharEscaper escaper, char c) {
    Assert.assertNull(computeReplacement(escaper, c));
  }

  /**
   * Asserts that a Unicode escaper does not escape the given character.
   *
   * @param escaper the non-null escaper to test
   * @param cp the Unicode code point to test
   */
  public static void assertUnescaped(UnicodeEscaper escaper, int cp) {

  @GwtIncompatible // doesn't build without explicit type parameters on build() methods
  public void testTreeKeys() {
    ListMultimap<String, Integer> multimap = MultimapBuilder.treeKeys().arrayListValues().build();
    assertTrue(multimap.keySet() instanceof SortedSet);
    assertTrue(multimap.asMap() instanceof SortedMap);
  }

  public void testTreeKeys_gwtCompatible() {
    ListMultimap<String, Integer> multimap =

 * @author mbechler
 *
 */
@SuppressWarnings ( "javadoc" )
public class NtlmTest {

    private CIFSContext context;


    @Before
    public void setUp () {
        this.context = SingletonContext.getInstance();
    }


    @Test
    public void testParsingType1 () throws IOException {
        int flags = 0x80000000;
        String suppliedDomain = "TESTDOM";
        String suppliedWorkstation = "TESTWS";

   * @param c the character to test
   */
  public static void assertUnescaped(CharEscaper escaper, char c) {
    Assert.assertNull(computeReplacement(escaper, c));
  }

  /**
   * Asserts that a Unicode escaper does not escape the given character.
   *
   * @param escaper the non-null escaper to test
   * @param cp the Unicode code point to test
   */
  public static void assertUnescaped(UnicodeEscaper escaper, int cp) {

    extends AbstractListMultimapTester<K, V> {
  public void testAsMapValuesImplementList() {
    for (Collection<V> valueCollection : multimap().asMap().values()) {
      assertTrue(valueCollection instanceof List);
    }
  }

  public void testAsMapGetImplementsList() {
    for (K key : multimap().keySet()) {
      assertTrue(multimap().asMap().get(key) instanceof List);

  abstract Condition delegate();

  @Override
  public void await() throws InterruptedException {
    delegate().await();
  }

  @Override
  public boolean await(long time, TimeUnit unit) throws InterruptedException {
    return delegate().await(time, unit);
  }

  @Override
  public void awaitUninterruptibly() {
    delegate().awaitUninterruptibly();
  }

  @Override

/**
 * Tests {@code Dependency}.
 *
 */
class DependencyTest {

    @Test
    void testHashCodeNullSafe() {
        new Dependency().hashCode();
    }

    @Test
    void testEqualsNullSafe() {
        assertFalse(new Dependency().equals(null));

        new Dependency().equals(new Dependency());
    }

    @Test
    void testEqualsIdentity() {
        Dependency thing = new Dependency();

 *
 */
class DistributionManagementTest {

    @Test
    void testHashCodeNullSafe() {
        new DistributionManagement().hashCode();
    }

    @Test
    void testEqualsNullSafe() {
        assertFalse(new DistributionManagement().equals(null));

        new DistributionManagement().equals(new DistributionManagement());
    }

    @Test
    void testEqualsIdentity() {

/**
 * Tests {@code Exclusion}.
 *
 */
class ExclusionTest {

    @Test
    void testHashCodeNullSafe() {
        new Exclusion().hashCode();
    }

    @Test
    void testEqualsNullSafe() {
        assertFalse(new Exclusion().equals(null));

        new Exclusion().equals(new Exclusion());
    }

    @Test
    void testEqualsIdentity() {
        Exclusion thing = new Exclusion();