private void visitPaths(final DirectoryStream<org.uberfire.java.nio.file.Path> directoryStream) {
    for (final org.uberfire.java.nio.file.Path path : directoryStream) {
      if (Files.isDirectory(path)) {
        visitPaths(Files.newDirectoryStream(path));

      } else {
        // Don't process dotFiles
        if (!dotFileFilter.accept(path)) {

          // Resource Type might require "external" validation (i.e. it's not covered by Kie)
          final BuildValidationHelper validator = getBuildValidationHelper(path);
          if (validator != null) {
            nonKieResourceValidationHelpers.put(path, validator);
          }

          // Add new resource
          final String destinationPath =
              path.toUri().toString().substring(projectPrefix.length() + 1);
          final InputStream is = ioService.newInputStream(path);
          final BufferedInputStream bis = new BufferedInputStream(is);
          kieFileSystem.write(
              destinationPath,
              KieServices.Factory.get().getResources().newInputStreamResource(bis));
          handles.put(getBaseFileName(destinationPath), Paths.convert(path));

          // Java classes are handled by KIE so we can safely post-process them here
          addJavaClass(path);
        }
      }
    }
  }
  private void buildIncrementally(
      final IncrementalBuildResults results, final String... destinationPath) {
    try {
      final IncrementalResults incrementalResults =
          ((InternalKieBuilder) kieBuilder).createFileSet(destinationPath).build();
      results.addAllAddedMessages(convertMessages(incrementalResults.getAddedMessages(), handles));
      results.addAllRemovedMessages(
          convertMessages(incrementalResults.getRemovedMessages(), handles));

      // Tidy-up removed message handles
      for (Message message : incrementalResults.getRemovedMessages()) {
        handles.remove(Handles.RESOURCE_PATH + "/" + getBaseFileName(message.getPath()));
      }

    } catch (LinkageError e) {
      final String msg = MessageFormat.format(ERROR_CLASS_NOT_FOUND, e.getLocalizedMessage());
      logger.warn(msg);
      results.addAddedMessage(makeWarningMessage(msg));

    } catch (Throwable e) {
      final String msg = e.getLocalizedMessage();
      logger.error(msg, e);
      results.addAddedMessage(makeErrorMessage(msg));
    }
  }
  public IncrementalBuildResults addResource(final Path resource) {
    synchronized (kieFileSystem) {
      checkNotNull("resource", resource);

      // Only files can be processed
      if (!Files.isRegularFile(resource)) {
        return new IncrementalBuildResults(projectGAV);
      }

      checkAFullBuildHasBeenPerformed();

      // Resource Type might require "external" validation (i.e. it's not covered by Kie)
      final IncrementalBuildResults results = new IncrementalBuildResults(projectGAV);
      final BuildValidationHelper validator = getBuildValidationHelper(resource);
      if (validator != null) {
        final List<ValidationMessage> addedValidationMessages =
            validator.validate(Paths.convert(resource));

        results.addAllAddedMessages(convertValidationMessages(addedValidationMessages));
        results.addAllRemovedMessages(
            convertValidationMessages(nonKieResourceValidationHelperMessages.remove(resource)));

        nonKieResourceValidationHelpers.put(resource, validator);
        nonKieResourceValidationHelperMessages.put(resource, addedValidationMessages);
      }

      // Add new resource
      final String destinationPath =
          resource.toUri().toString().substring(projectPrefix.length() + 1);
      final InputStream is = ioService.newInputStream(resource);
      final BufferedInputStream bis = new BufferedInputStream(is);
      kieFileSystem.write(
          destinationPath, KieServices.Factory.get().getResources().newInputStreamResource(bis));
      addJavaClass(resource);
      handles.put(getBaseFileName(destinationPath), Paths.convert(resource));

      buildIncrementally(results, destinationPath);

      return results;
    }
  }
  private void update(
      final List<ValidationMessage> nonKieResourceValidatorAddedMessages,
      final List<ValidationMessage> nonKieResourceValidatorRemovedMessages,
      final Path resource,
      final String destinationPath) {
    // Resource Type might require "external" validation (i.e. it's not covered by Kie)
    final BuildValidationHelper validator = getBuildValidationHelper(resource);
    if (validator != null) {
      final List<ValidationMessage> addedValidationMessages =
          validator.validate(Paths.convert(resource));

      if (!(addedValidationMessages == null || addedValidationMessages.isEmpty())) {
        for (ValidationMessage validationMessage : addedValidationMessages) {
          nonKieResourceValidatorAddedMessages.add(validationMessage);
        }
      }

      final List<ValidationMessage> removedValidationMessages =
          nonKieResourceValidationHelperMessages.remove(resource);
      if (!(removedValidationMessages == null || removedValidationMessages.isEmpty())) {
        for (ValidationMessage validationMessage : removedValidationMessages) {
          nonKieResourceValidatorRemovedMessages.add(validationMessage);
        }
      }
      nonKieResourceValidationHelpers.put(resource, validator);
      nonKieResourceValidationHelperMessages.put(resource, addedValidationMessages);
    }

    // Add new resource
    final InputStream is = ioService.newInputStream(resource);
    final BufferedInputStream bis = new BufferedInputStream(is);
    kieFileSystem.write(
        destinationPath, KieServices.Factory.get().getResources().newInputStreamResource(bis));
    addJavaClass(resource);
    handles.put(getBaseFileName(destinationPath), Paths.convert(resource));
  }
  static void testArray(Handles hs) throws Throwable {
    int[] array = new int[10];

    for (int i = 0; i < array.length; i++) {
      // Plain
      {
        hs.get(TestAccessMode.SET).invokeExact(array, i, 0x01234567);
        int x = (int) hs.get(TestAccessMode.GET).invokeExact(array, i);
        assertEquals(x, 0x01234567, "get int value");
      }

      // Volatile
      {
        hs.get(TestAccessMode.SET_VOLATILE).invokeExact(array, i, 0x89ABCDEF);
        int x = (int) hs.get(TestAccessMode.GET_VOLATILE).invokeExact(array, i);
        assertEquals(x, 0x89ABCDEF, "setVolatile int value");
      }

      // Lazy
      {
        hs.get(TestAccessMode.SET_RELEASE).invokeExact(array, i, 0x01234567);
        int x = (int) hs.get(TestAccessMode.GET_ACQUIRE).invokeExact(array, i);
        assertEquals(x, 0x01234567, "setRelease int value");
      }

      // Opaque
      {
        hs.get(TestAccessMode.SET_OPAQUE).invokeExact(array, i, 0x89ABCDEF);
        int x = (int) hs.get(TestAccessMode.GET_OPAQUE).invokeExact(array, i);
        assertEquals(x, 0x89ABCDEF, "setOpaque int value");
      }

      hs.get(TestAccessMode.SET).invokeExact(array, i, 0x01234567);

      // Compare
      {
        boolean r =
            (boolean)
                hs.get(TestAccessMode.COMPARE_AND_SET)
                    .invokeExact(array, i, 0x01234567, 0x89ABCDEF);
        assertEquals(r, true, "success compareAndSet int");
        int x = (int) hs.get(TestAccessMode.GET).invokeExact(array, i);
        assertEquals(x, 0x89ABCDEF, "success compareAndSet int value");
      }

      {
        boolean r =
            (boolean)
                hs.get(TestAccessMode.COMPARE_AND_SET)
                    .invokeExact(array, i, 0x01234567, 0xCAFEBABE);
        assertEquals(r, false, "failing compareAndSet int");
        int x = (int) hs.get(TestAccessMode.GET).invokeExact(array, i);
        assertEquals(x, 0x89ABCDEF, "failing compareAndSet int value");
      }

      {
        int r =
            (int)
                hs.get(TestAccessMode.COMPARE_AND_EXCHANGE)
                    .invokeExact(array, i, 0x89ABCDEF, 0x01234567);
        assertEquals(r, 0x89ABCDEF, "success compareAndExchange int");
        int x = (int) hs.get(TestAccessMode.GET).invokeExact(array, i);
        assertEquals(x, 0x01234567, "success compareAndExchange int value");
      }

      {
        int r =
            (int)
                hs.get(TestAccessMode.COMPARE_AND_EXCHANGE)
                    .invokeExact(array, i, 0x89ABCDEF, 0xCAFEBABE);
        assertEquals(r, 0x01234567, "failing compareAndExchange int");
        int x = (int) hs.get(TestAccessMode.GET).invokeExact(array, i);
        assertEquals(x, 0x01234567, "failing compareAndExchange int value");
      }

      {
        int r =
            (int)
                hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE)
                    .invokeExact(array, i, 0x01234567, 0x89ABCDEF);
        assertEquals(r, 0x01234567, "success compareAndExchangeAcquire int");
        int x = (int) hs.get(TestAccessMode.GET).invokeExact(array, i);
        assertEquals(x, 0x89ABCDEF, "success compareAndExchangeAcquire int value");
      }

      {
        int r =
            (int)
                hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_ACQUIRE)
                    .invokeExact(array, i, 0x01234567, 0xCAFEBABE);
        assertEquals(r, 0x89ABCDEF, "failing compareAndExchangeAcquire int");
        int x = (int) hs.get(TestAccessMode.GET).invokeExact(array, i);
        assertEquals(x, 0x89ABCDEF, "failing compareAndExchangeAcquire int value");
      }

      {
        int r =
            (int)
                hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE)
                    .invokeExact(array, i, 0x89ABCDEF, 0x01234567);
        assertEquals(r, 0x89ABCDEF, "success compareAndExchangeRelease int");
        int x = (int) hs.get(TestAccessMode.GET).invokeExact(array, i);
        assertEquals(x, 0x01234567, "success compareAndExchangeRelease int value");
      }

      {
        int r =
            (int)
                hs.get(TestAccessMode.COMPARE_AND_EXCHANGE_RELEASE)
                    .invokeExact(array, i, 0x89ABCDEF, 0xCAFEBABE);
        assertEquals(r, 0x01234567, "failing compareAndExchangeRelease int");
        int x = (int) hs.get(TestAccessMode.GET).invokeExact(array, i);
        assertEquals(x, 0x01234567, "failing compareAndExchangeRelease int value");
      }

      {
        boolean success = false;
        for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
          success =
              (boolean)
                  hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_PLAIN)
                      .invokeExact(array, i, 0x01234567, 0x89ABCDEF);
        }
        assertEquals(success, true, "weakCompareAndSetPlain int");
        int x = (int) hs.get(TestAccessMode.GET).invokeExact(array, i);
        assertEquals(x, 0x89ABCDEF, "weakCompareAndSetPlain int value");
      }

      {
        boolean success = false;
        for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
          success =
              (boolean)
                  hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_ACQUIRE)
                      .invokeExact(array, i, 0x89ABCDEF, 0x01234567);
        }
        assertEquals(success, true, "weakCompareAndSetAcquire int");
        int x = (int) hs.get(TestAccessMode.GET).invokeExact(array, i);
        assertEquals(x, 0x01234567, "weakCompareAndSetAcquire int");
      }

      {
        boolean success = false;
        for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
          success =
              (boolean)
                  hs.get(TestAccessMode.WEAK_COMPARE_AND_SET_RELEASE)
                      .invokeExact(array, i, 0x01234567, 0x89ABCDEF);
        }
        assertEquals(success, true, "weakCompareAndSetRelease int");
        int x = (int) hs.get(TestAccessMode.GET).invokeExact(array, i);
        assertEquals(x, 0x89ABCDEF, "weakCompareAndSetRelease int");
      }

      {
        boolean success = false;
        for (int c = 0; c < WEAK_ATTEMPTS && !success; c++) {
          success =
              (boolean)
                  hs.get(TestAccessMode.WEAK_COMPARE_AND_SET)
                      .invokeExact(array, i, 0x89ABCDEF, 0x01234567);
        }
        assertEquals(success, true, "weakCompareAndSet int");
        int x = (int) hs.get(TestAccessMode.GET).invokeExact(array, i);
        assertEquals(x, 0x01234567, "weakCompareAndSet int");
      }

      // Compare set and get
      {
        hs.get(TestAccessMode.SET).invokeExact(array, i, 0x01234567);

        int o = (int) hs.get(TestAccessMode.GET_AND_SET).invokeExact(array, i, 0x89ABCDEF);
        assertEquals(o, 0x01234567, "getAndSet int");
        int x = (int) hs.get(TestAccessMode.GET).invokeExact(array, i);
        assertEquals(x, 0x89ABCDEF, "getAndSet int value");
      }

      {
        hs.get(TestAccessMode.SET).invokeExact(array, i, 0x01234567);

        int o = (int) hs.get(TestAccessMode.GET_AND_SET_ACQUIRE).invokeExact(array, i, 0x89ABCDEF);
        assertEquals(o, 0x01234567, "getAndSetAcquire int");
        int x = (int) hs.get(TestAccessMode.GET).invokeExact(array, i);
        assertEquals(x, 0x89ABCDEF, "getAndSetAcquire int value");
      }

      {
        hs.get(TestAccessMode.SET).invokeExact(array, i, 0x01234567);

        int o = (int) hs.get(TestAccessMode.GET_AND_SET_RELEASE).invokeExact(array, i, 0x89ABCDEF);
        assertEquals(o, 0x01234567, "getAndSetRelease int");
        int x = (int) hs.get(TestAccessMode.GET).invokeExact(array, i);
        assertEquals(x, 0x89ABCDEF, "getAndSetRelease int value");
      }

      // get and add, add and get
      {
        hs.get(TestAccessMode.SET).invokeExact(array, i, 0x01234567);

        int o = (int) hs.get(TestAccessMode.GET_AND_ADD).invokeExact(array, i, 0x89ABCDEF);
        assertEquals(o, 0x01234567, "getAndAdd int");
        int x = (int) hs.get(TestAccessMode.GET).invokeExact(array, i);
        assertEquals(x, (int) (0x01234567 + 0x89ABCDEF), "getAndAdd int value");
      }

      {
        hs.get(TestAccessMode.SET).invokeExact(array, i, 0x01234567);

        int o = (int) hs.get(TestAccessMode.GET_AND_ADD_ACQUIRE).invokeExact(array, i, 0x89ABCDEF);
        assertEquals(o, 0x01234567, "getAndAddAcquire int");
        int x = (int) hs.get(TestAccessMode.GET).invokeExact(array, i);
        assertEquals(x, (int) (0x01234567 + 0x89ABCDEF), "getAndAddAcquire int value");
      }

      {
        hs.get(TestAccessMode.SET).invokeExact(array, i, 0x01234567);

        int o = (int) hs.get(TestAccessMode.GET_AND_ADD_RELEASE).invokeExact(array, i, 0x89ABCDEF);
        assertEquals(o, 0x01234567, "getAndAddRelease int");
        int x = (int) hs.get(TestAccessMode.GET).invokeExact(array, i);
        assertEquals(x, (int) (0x01234567 + 0x89ABCDEF), "getAndAddRelease int value");
      }

      // get and bitwise or
      {
        hs.get(TestAccessMode.SET).invokeExact(array, i, 0x01234567);

        int o = (int) hs.get(TestAccessMode.GET_AND_BITWISE_OR).invokeExact(array, i, 0x89ABCDEF);
        assertEquals(o, 0x01234567, "getAndBitwiseOr int");
        int x = (int) hs.get(TestAccessMode.GET).invokeExact(array, i);
        assertEquals(x, (int) (0x01234567 | 0x89ABCDEF), "getAndBitwiseOr int value");
      }

      {
        hs.get(TestAccessMode.SET).invokeExact(array, i, 0x01234567);

        int o =
            (int)
                hs.get(TestAccessMode.GET_AND_BITWISE_OR_ACQUIRE).invokeExact(array, i, 0x89ABCDEF);
        assertEquals(o, 0x01234567, "getAndBitwiseOrAcquire int");
        int x = (int) hs.get(TestAccessMode.GET).invokeExact(array, i);
        assertEquals(x, (int) (0x01234567 | 0x89ABCDEF), "getAndBitwiseOrAcquire int value");
      }

      {
        hs.get(TestAccessMode.SET).invokeExact(array, i, 0x01234567);

        int o =
            (int)
                hs.get(TestAccessMode.GET_AND_BITWISE_OR_RELEASE).invokeExact(array, i, 0x89ABCDEF);
        assertEquals(o, 0x01234567, "getAndBitwiseOrRelease int");
        int x = (int) hs.get(TestAccessMode.GET).invokeExact(array, i);
        assertEquals(x, (int) (0x01234567 | 0x89ABCDEF), "getAndBitwiseOrRelease int value");
      }

      // get and bitwise and
      {
        hs.get(TestAccessMode.SET).invokeExact(array, i, 0x01234567);

        int o = (int) hs.get(TestAccessMode.GET_AND_BITWISE_AND).invokeExact(array, i, 0x89ABCDEF);
        assertEquals(o, 0x01234567, "getAndBitwiseAnd int");
        int x = (int) hs.get(TestAccessMode.GET).invokeExact(array, i);
        assertEquals(x, (int) (0x01234567 & 0x89ABCDEF), "getAndBitwiseAnd int value");
      }

      {
        hs.get(TestAccessMode.SET).invokeExact(array, i, 0x01234567);

        int o =
            (int)
                hs.get(TestAccessMode.GET_AND_BITWISE_AND_ACQUIRE)
                    .invokeExact(array, i, 0x89ABCDEF);
        assertEquals(o, 0x01234567, "getAndBitwiseAndAcquire int");
        int x = (int) hs.get(TestAccessMode.GET).invokeExact(array, i);
        assertEquals(x, (int) (0x01234567 & 0x89ABCDEF), "getAndBitwiseAndAcquire int value");
      }

      {
        hs.get(TestAccessMode.SET).invokeExact(array, i, 0x01234567);

        int o =
            (int)
                hs.get(TestAccessMode.GET_AND_BITWISE_AND_RELEASE)
                    .invokeExact(array, i, 0x89ABCDEF);
        assertEquals(o, 0x01234567, "getAndBitwiseAndRelease int");
        int x = (int) hs.get(TestAccessMode.GET).invokeExact(array, i);
        assertEquals(x, (int) (0x01234567 & 0x89ABCDEF), "getAndBitwiseAndRelease int value");
      }

      // get and bitwise xor
      {
        hs.get(TestAccessMode.SET).invokeExact(array, i, 0x01234567);

        int o = (int) hs.get(TestAccessMode.GET_AND_BITWISE_XOR).invokeExact(array, i, 0x89ABCDEF);
        assertEquals(o, 0x01234567, "getAndBitwiseXor int");
        int x = (int) hs.get(TestAccessMode.GET).invokeExact(array, i);
        assertEquals(x, (int) (0x01234567 ^ 0x89ABCDEF), "getAndBitwiseXor int value");
      }

      {
        hs.get(TestAccessMode.SET).invokeExact(array, i, 0x01234567);

        int o =
            (int)
                hs.get(TestAccessMode.GET_AND_BITWISE_XOR_ACQUIRE)
                    .invokeExact(array, i, 0x89ABCDEF);
        assertEquals(o, 0x01234567, "getAndBitwiseXorAcquire int");
        int x = (int) hs.get(TestAccessMode.GET).invokeExact(array, i);
        assertEquals(x, (int) (0x01234567 ^ 0x89ABCDEF), "getAndBitwiseXorAcquire int value");
      }

      {
        hs.get(TestAccessMode.SET).invokeExact(array, i, 0x01234567);

        int o =
            (int)
                hs.get(TestAccessMode.GET_AND_BITWISE_XOR_RELEASE)
                    .invokeExact(array, i, 0x89ABCDEF);
        assertEquals(o, 0x01234567, "getAndBitwiseXorRelease int");
        int x = (int) hs.get(TestAccessMode.GET).invokeExact(array, i);
        assertEquals(x, (int) (0x01234567 ^ 0x89ABCDEF), "getAndBitwiseXorRelease int value");
      }
    }
  }
  static void testArrayIndexOutOfBounds(Handles hs) throws Throwable {
    int[] array = new int[10];

    for (int i : new int[] {-1, Integer.MIN_VALUE, 10, 11, Integer.MAX_VALUE}) {
      final int ci = i;

      for (TestAccessMode am : testAccessModesOfType(TestAccessType.GET)) {
        checkIOOBE(
            am,
            () -> {
              int x = (int) hs.get(am).invokeExact(array, ci);
            });
      }

      for (TestAccessMode am : testAccessModesOfType(TestAccessType.SET)) {
        checkIOOBE(
            am,
            () -> {
              hs.get(am).invokeExact(array, ci, 0x01234567);
            });
      }

      for (TestAccessMode am : testAccessModesOfType(TestAccessType.COMPARE_AND_SET)) {
        checkIOOBE(
            am,
            () -> {
              boolean r = (boolean) hs.get(am).invokeExact(array, ci, 0x01234567, 0x89ABCDEF);
            });
      }

      for (TestAccessMode am : testAccessModesOfType(TestAccessType.COMPARE_AND_EXCHANGE)) {
        checkIOOBE(
            am,
            () -> {
              int r = (int) hs.get(am).invokeExact(array, ci, 0x89ABCDEF, 0x01234567);
            });
      }

      for (TestAccessMode am : testAccessModesOfType(TestAccessType.GET_AND_SET)) {
        checkIOOBE(
            am,
            () -> {
              int o = (int) hs.get(am).invokeExact(array, ci, 0x01234567);
            });
      }

      for (TestAccessMode am : testAccessModesOfType(TestAccessType.GET_AND_ADD)) {
        checkIOOBE(
            am,
            () -> {
              int o = (int) hs.get(am).invokeExact(array, ci, 0xCAFEBABE);
            });
      }

      for (TestAccessMode am : testAccessModesOfType(TestAccessType.GET_AND_BITWISE)) {
        checkIOOBE(
            am,
            () -> {
              int o = (int) hs.get(am).invokeExact(array, ci, 0xCAFEBABE);
            });
      }
    }
  }