AvlNode<E> newRoot = new AvlNode<>(element, occurrences);
      successor(header, newRoot, header);
      rootReference.checkAndSet(root, newRoot);
      return 0;
    }
    int[] result = new int[1]; // used as a mutable int reference to hold result
    AvlNode<E> newRoot = root.add(comparator(), element, occurrences, result);
    rootReference.checkAndSet(root, newRoot);
    return result[0];
  }

      AvlNode<E> newRoot = new AvlNode<>(element, occurrences);
      successor(header, newRoot, header);
      rootReference.checkAndSet(root, newRoot);
      return 0;
    }
    int[] result = new int[1]; // used as a mutable int reference to hold result
    AvlNode<E> newRoot = root.add(comparator(), element, occurrences, result);
    rootReference.checkAndSet(root, newRoot);
    return result[0];
  }

	}

	// Try to escalate privileges
	restrictedAdmClient := s.getAdminClient(c, "restricted", "restricted123", "")
	_, err = restrictedAdmClient.AddServiceAccount(ctx, madmin.AddServiceAccountReq{
		AccessKey: "newroot",
		SecretKey: "newroot123",
	})
	if err == nil {
		c.Fatalf("restricted service account was able to create service account bypassing sub-policy!")
	}
}

	restrictedAdmClient := s.getAdminClient(c, value.AccessKeyID, value.SecretAccessKey, value.SessionToken)
	_, err = restrictedAdmClient.AddServiceAccount(ctx, madmin.AddServiceAccountReq{
		AccessKey: "newroot",
		SecretKey: "newroot123",
	})
	if err == nil {
		c.Fatalf("restricted STS account was able to create service account bypassing sub-policy!")
	}
}

func (s *TestSuiteIAM) TestSTSWithTags(c *check) {

            node = repoSystem.collectDependencies(pluginSession, request).getRoot();

            if (logger.isDebugEnabled()) {
                node.accept(new DependencyGraphDumper(logger::debug));
            }

            depRequest.setRoot(node);
            return repoSystem.resolveDependencies(session, depRequest);
        } catch (DependencyCollectionException e) {

            collect.setTrace(RequestTrace.newChild(trace, depRequest));
            node = repoSystem.collectDependencies(session, collect).getRoot();
            result.setDependencyGraph(node);
        } catch (DependencyCollectionException e) {
            result.setDependencyGraph(e.getResult().getRoot());
            result.setCollectionErrors(e.getResult().getExceptions());

            throw new DependencyResolutionException(

        CollectRequest collectRequest = new CollectRequest();
        collectRequest.setRoot(new Dependency(artifact, null));
        collectRequest.addRepository(newTestRepository());

        CollectResult collectResult = system.collectDependencies(session, collectRequest);

        List<DependencyNode> nodes = collectResult.getRoot().getChildren();
        assertEquals(2, nodes.size());
        checkUtSimpleArtifactDependencies(

    }

    /**
     * Test isPathSafe with safe path
     *
     * @throws Exception
     */
    @Test
    public void testIsPathSafe_SafePath() throws Exception {
        final Path baseDir = tempFolder.getRoot().toPath();
        final Path safePath = baseDir.resolve("subdir/file.txt");

        assertTrue("Safe path should be allowed", FileUtil.isPathSafe(safePath, baseDir));
    }

    /**

  private val addressA = factory.newAddress("a")
  private val routeA1 = factory.newRoute(addressA)
  private val addressB = factory.newAddress("b")
  private val routeB1 = factory.newRoute(addressB)
  private val addressC = factory.newAddress("c")
  private val routeC1 = factory.newRoute(addressC)

  @AfterEach fun tearDown() {
    factory.close()
    peer.close()
  }

        Thread.sleep(100);
        try (FileWriter writer = new FileWriter(lmhostsFile)) {
            writer.write("192.168.1.200 NEWHOST\n");
        }

        // Should reload file and find new host
        result = lmhosts.getByName("NEWHOST", mockContext);
        assertNotNull(result);

        // Old host should not be found
        result = lmhosts.getByName("TESTHOST", mockContext);