// allows depMgmt to always override transitive dependencies, while
        // explicit child override depMgmt (viz. depMgmt should only
        // provide defaults to children, but should override transitives).
        // We can do this by calling isChildOfRootNode on the current node.
        if ((artifact.getVersion() != null)

        assertNotNull(component1);
        assertNotNull(component2);

        // Should be same instance for singleton
        assertSame(component1, component2);
        // The first creation should increment the counter
        assertTrue("Instance count should be at least 1", SingletonTestComponent.getInstanceCount() >= 1);
    }

    /**
     * Test wrap method
     */

        assertEquals(mockSids, msrpcGetMembersInAlias.sids, "sids should be set correctly");
        assertEquals(0, msrpcGetMembersInAlias.getPtype(), "ptype should be initialized to 0");
        assertEquals(DCERPC_FIRST_FRAG | DCERPC_LAST_FRAG, msrpcGetMembersInAlias.getFlags(),
                "flags should be set to DCERPC_FIRST_FRAG | DCERPC_LAST_FRAG");
    }

   * should use this method over {@link #setCountCheckReturnValue(Object, int)} when they expect
   * {@code setCount()} to throw an exception, as checking the return value could produce an
   * incorrect error message like "setCount() should return the original count" instead of the
   * message passed to a later invocation of {@code fail()}, like "setCount should throw
   * UnsupportedOperationException."
   */

                "tearDownTwo should have been run before tearDownOne", false, tearDownOne.ran);
          }
        };

    SimpleTearDown tearDownTwo = new SimpleTearDown(callback);
    stack.addTearDown(tearDownTwo);

    assertEquals(false, tearDownOne.ran);
    assertEquals(false, tearDownTwo.ran);

    stack.runTearDown();

    assertEquals("tearDownOne should have run", true, tearDownOne.ran);

        assertEquals(2, problems.size(), "Should collect both problems");
        assertEquals(Problem.Severity.ERROR, problems.get(0).getSeverity(), "First problem should be ERROR");
        assertEquals("Error message", problems.get(0).getMessage(), "First problem should have correct message");
        assertEquals(Problem.Severity.WARNING, problems.get(1).getSeverity(), "Second problem should be WARNING");
    }

    lockB.unlock();

    // The opposite order should fail (Policies.THROW).
    PotentialDeadlockException firstException = null;
    lockB.lock();
    PotentialDeadlockException expected =
        assertThrows(PotentialDeadlockException.class, () -> lockA.lock());
    checkMessage(expected, "LockB -> LockA", "LockA -> LockB");
    firstException = expected;
    // Second time should also fail, with a cached causal chain.

            CrawlerStatus.valueOf("INVALID");
            fail("Should throw IllegalArgumentException for invalid value");
        } catch (IllegalArgumentException e) {
            // Expected
            assertTrue(e.getMessage().contains("INVALID"));
        }

        try {
            CrawlerStatus.valueOf("initializing"); // lowercase
            fail("Should throw IllegalArgumentException for lowercase value");

      assertErrorMessage(
          e, obj + " must not be Object#equals to an arbitrary object of another class");
      return;
    }
    fail("Should get equal to incompatible class error");
  }

  /** Test proper handling where an object is not equal to one the user has said should be equal */
  public void testInvalidNotEqualsEqualObject() {
    equalsTester.addEqualityGroup(reference, notEqualObject1);
    try {

        }

        when(mockConfig.getLmHostsFileName()).thenReturn(lmhostsFile.getAbsolutePath());

        // First call should read the file
        NbtAddress result1 = lmhosts.getByName("TESTHOST", mockContext);
        assertNotNull(result1);

        // Second call should use cached data (file not modified)
        NbtAddress result2 = lmhosts.getByName("TESTHOST", mockContext);
        assertNotNull(result2);