NodeDiffListener NOOP = new NodeDiffListener() {
            @Override
            public void nodeRemoved(FileSystemNode node) {
            }

            @Override
            public void nodeAdded(FileSystemNode node) {
            }
        };

        /**
         * Called when a node is removed during the update.
         *

                    public void nodeAdded(FileSystemNode node) {
                        diffListener.nodeAdded(node);
                    }
                });
                children.stream()
                    .map(ChildMap.Entry::getValue)
                    .filter(existingChild -> existingChild != child)
                    .forEach(diffListener::nodeAdded);
                return invalidated;
            }

                    diffListener.nodeAdded(newChild);
                    return newChild;
                } else {
                    return child;
                }
            }

            @Override
            public FileSystemNode createChild() {
                FileSystemNode newChild = snapshot.asFileSystemNode();
                diffListener.nodeAdded(newChild);
                return newChild;

        }
    }

    @Override
    public void nodeRemoved(FileSystemNode node) {
        node.rootSnapshots()
            .forEach(removedSnapshots::add);
    }

    @Override
    public void nodeAdded(FileSystemNode node) {
        node.rootSnapshots()
            .forEach(addedSnapshots::add);
    }

        @Override
        void nodeRemoved(FileSystemNode node) {
            removedSnapshots.add(node)
        }

        @Override
        void nodeAdded(FileSystemNode node) {
            addedSnapshots.add(node)
        }
    }

    def "store is ignored"() {
        def snapshot = Mock(MetadataSnapshot)

        expect:

            this.dependencyCount = node.getDependencySuccessors().size();
            this.readyNode = readyNode;
        }
    }

    private static class NodeAdded extends AbstractNodeEvent {
        public NodeAdded(Node node, String whenAdded, boolean readyNode) {
            super(node, whenAdded, readyNode);
        }

        @Override
        public String message() {

            FileSystemNode rootNode = snapshot.getType() == FileType.Missing
                ? new UnknownFileSystemNode(children)
                : new PartialDirectoryNode(children);
            diffListener.nodeAdded(rootNode);
            return from(rootNode, caseSensitivity);
        }

        @Override
        public SnapshotHierarchy invalidate(String absolutePath, NodeDiffListener diffListener) {
            return this;

            maybeLogVfsChangeMessage();
            delegate.nodeRemoved(node);
        }

        @Override
        public void nodeAdded(FileSystemNode node) {
            maybeLogVfsChangeMessage();
            delegate.nodeAdded(node);
        }

        private void maybeLogVfsChangeMessage() {
            if (!alreadyLogged) {
                alreadyLogged = true;

        @Override
        void nodeRemoved(FileSystemNode node) {
            removedNodes.add(node)
        }

        @Override
        void nodeAdded(FileSystemNode node) {
            addedNodes.add(node)
        }
    }

    String selectedChildPath
    /**
     * The child, if any, which has a common prefix with the selected path.
     */

			// NodeAdded QueueingHint isn't always called because of preCheck.
			// It's definitely not something expected for plugin developers,
			// and registering UpdateNodeTaint event is the only mitigation for now.
			//
			// So, here registers UpdateNodeTaint event for plugins that has NodeAdded event, but don't have UpdateNodeTaint event.