diff --git a/src/main/java/org/springframework/data/gemfire/support/AnnotationBasedExpiration.java b/src/main/java/org/springframework/data/gemfire/support/AnnotationBasedExpiration.java index f58b7d1e..a480cb25 100644 --- a/src/main/java/org/springframework/data/gemfire/support/AnnotationBasedExpiration.java +++ b/src/main/java/org/springframework/data/gemfire/support/AnnotationBasedExpiration.java @@ -60,18 +60,10 @@ import org.springframework.util.ObjectUtils; * @see org.springframework.data.gemfire.support.Expiration * @see org.springframework.data.gemfire.support.IdleTimeoutExpiration * @see org.springframework.data.gemfire.support.TimeToLiveExpiration -<<<<<<< HEAD * @see org.apache.geode.cache.CustomExpiry * @see org.apache.geode.cache.ExpirationAction * @see org.apache.geode.cache.ExpirationAttributes * @see org.apache.geode.cache.Region -======= - * @see org.apache.geode.cache.CustomExpiry - * @see org.apache.geode.cache.ExpirationAction - * @see org.apache.geode.cache.ExpirationAttributes - * @see org.apache.geode.cache.Region - * @see Annotation-based Data Expiration ->>>>>>> bfb3347... SGF-516 - Configure Expiration with annotations. * @since 1.7.0 */ @SuppressWarnings("unused") diff --git a/src/test/java/org/springframework/data/gemfire/GenericRegionFactoryBeanTest.java b/src/test/java/org/springframework/data/gemfire/GenericRegionFactoryBeanTest.java index 73f3482b..00688589 100644 --- a/src/test/java/org/springframework/data/gemfire/GenericRegionFactoryBeanTest.java +++ b/src/test/java/org/springframework/data/gemfire/GenericRegionFactoryBeanTest.java @@ -18,6 +18,9 @@ package org.springframework.data.gemfire; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertNotNull; +import static org.springframework.data.gemfire.test.support.FileSystemUtils.FileExtensionFilter.newFileExtensionFilter; + +import java.io.FileFilter; import org.apache.geode.cache.Cache; import org.apache.geode.cache.CacheFactory; @@ -27,18 +30,20 @@ import org.apache.geode.cache.Scope; import org.junit.AfterClass; import org.junit.BeforeClass; import org.junit.Test; +import org.springframework.data.gemfire.test.support.FileSystemUtils; +import org.springframework.data.gemfire.util.CacheUtils; /** - * The GenericRegionFactoryBeanTest class is a test suite of test cases testing the contract and functionality - * of the GenericRegionFactoryBean class. + * Unit tests for {@link GenericRegionFactoryBean}. * * @author John Blum + * @see org.junit.Test * @see org.springframework.data.gemfire.GenericRegionFactoryBean * @since 1.7.0 */ public class GenericRegionFactoryBeanTest { - // as defined in the org.apache.geode.internal.cache.AbstractRegion class + // As defined in com.gemstone.gemfire.internal.cache.AbstractRegion private static final Scope DEFAULT_SCOPE = Scope.DISTRIBUTED_NO_ACK; private static Region defaultRegion; @@ -120,21 +125,25 @@ public class GenericRegionFactoryBeanTest { @AfterClass public static void tearDown() { - try { - CacheFactory.getAnyInstance().close(); - } - catch (Exception ignore) { - } + CacheUtils.closeCache(); + + FileFilter fileFilter = FileSystemUtils.CompositeFileFilter.or( + newFileExtensionFilter(".if"), newFileExtensionFilter(".crf"), newFileExtensionFilter(".drf"), + newFileExtensionFilter(".log")); + + FileSystemUtils.deleteRecursive(FileSystemUtils.WORKING_DIRECTORY, fileFilter); } protected void assertRegionAttributes(Region region, String expectedRegionName, DataPolicy expectedDataPolicy, Scope expectedScope) { + assertRegionAttributes(region, expectedRegionName, String.format("%1$s%2$s", Region.SEPARATOR, expectedRegionName), expectedDataPolicy, expectedScope); } protected void assertRegionAttributes(Region region, String expectedRegionName, String expectedRegionPath, DataPolicy expectedDataPolicy, Scope expectedScope) { + assertNotNull("The GemFire Cache Region must not be null!", region); assertEquals(expectedRegionName, region.getName()); assertEquals(expectedRegionPath, region.getFullPath()); @@ -178,5 +187,4 @@ public class GenericRegionFactoryBeanTest { public void replicateRegionAttributes() { assertRegionAttributes(replicateRegion, "ReplicateRegion", DataPolicy.REPLICATE, Scope.GLOBAL); } - } diff --git a/src/test/java/org/springframework/data/gemfire/test/support/FileSystemUtils.java b/src/test/java/org/springframework/data/gemfire/test/support/FileSystemUtils.java index 964d1c8e..0395628d 100644 --- a/src/test/java/org/springframework/data/gemfire/test/support/FileSystemUtils.java +++ b/src/test/java/org/springframework/data/gemfire/test/support/FileSystemUtils.java @@ -16,6 +16,9 @@ package org.springframework.data.gemfire.test.support; +import static org.springframework.data.gemfire.util.ArrayUtils.nullSafeArray; +import static org.springframework.data.gemfire.util.CollectionUtils.nullSafeIterable; + import java.io.File; import java.io.FileFilter; import java.util.ArrayList; @@ -25,8 +28,8 @@ import java.util.List; import org.springframework.util.Assert; /** - * The FileSystemUtils class is a utility class encapsulating functionality to process file system directories - * and files collectively. + * The {@link FileSystemUtils} class is a utility class encapsulating functionality to process + * file system directories and files collectively. * * @author John Blum * @see java.io.File @@ -40,14 +43,23 @@ public abstract class FileSystemUtils extends FileUtils { public static final File JAVA_HOME = new File(System.getProperty("java.home")); public static final File JAVA_EXE = new File(new File(JAVA_HOME, "bin"), "java"); + public static final File TEMPORARY_DIRECTORY = new File(System.getProperty("java.io.tmpdir")); public static final File USER_HOME = new File(System.getProperty("user.home")); public static final File WORKING_DIRECTORY = new File(System.getProperty("user.dir")); + public static final File[] NO_FILES = new File[0]; + + /* (non-Javadoc) */ public static boolean deleteRecursive(File path) { + return deleteRecursive(path, AllFilesFilter.INSTANCE); + } + + /* (non-Javadoc) */ + public static boolean deleteRecursive(File path, FileFilter fileFilter) { boolean success = true; if (isDirectory(path)) { - for (File file : safeListFiles(path)) { + for (File file : safeListFiles(path, fileFilter)) { success &= deleteRecursive(file); } } @@ -72,9 +84,10 @@ public abstract class FileSystemUtils extends FileUtils { return (localPath != null ? localPath : path); } + /* (non-Javadoc) */ public static File[] listFiles(File directory, FileFilter fileFilter) { - Assert.isTrue(isDirectory(directory), String.format( "File (%1$s) does not refer to a valid directory", - directory)); + Assert.isTrue(isDirectory(directory), String.format( + "File [%s] does not refer to a valid directory", directory)); List results = new ArrayList(); @@ -90,42 +103,147 @@ public abstract class FileSystemUtils extends FileUtils { return results.toArray(new File[results.size()]); } + /* (non-Javadoc) */ public static File[] safeListFiles(File directory) { - return safeListFiles(directory, AllFiles.INSTANCE); + return safeListFiles(directory, AllFilesFilter.INSTANCE); } + /* (non-Javadoc) */ public static File[] safeListFiles(File directory, FileFilter fileFilter) { - File[] files = (directory != null ? directory.listFiles(fileFilter) : null); - return (files != null ? files : new File[0]); + FileFilter resolvedFileFilter = (fileFilter != null ? fileFilter : AllFilesFilter.INSTANCE); + File[] files = (isDirectory(directory) ? directory.listFiles(resolvedFileFilter) : null); + return (files != null ? files : NO_FILES); } - public static final class AllFiles implements FileFilter { + public static class AllFilesFilter implements FileFilter { - public static final AllFiles INSTANCE = new AllFiles(); + public static final AllFilesFilter INSTANCE = new AllFilesFilter(); @Override - public boolean accept(final File pathname) { + public boolean accept(File pathname) { return true; } } - public static final class FileOnlyFilter implements FileFilter { + public static class CompositeFileFilter implements FileFilter { - public static final FileOnlyFilter INSTANCE = new FileOnlyFilter(); + private final FileFilter fileFilterOne; + private final FileFilter fileFilterTwo; + + private final LogicalOperator logicalOperator; + + private CompositeFileFilter(FileFilter fileFilterOne, LogicalOperator operator, FileFilter fileFilterTwo) { + this.fileFilterOne = fileFilterOne; + this.logicalOperator = operator; + this.fileFilterTwo = fileFilterTwo; + } + + protected static FileFilter compose(FileFilter fileFilterOne, LogicalOperator operator, FileFilter fileFilterTwo) { + return (fileFilterOne == null ? fileFilterTwo : (fileFilterTwo == null ? fileFilterOne + : new CompositeFileFilter(fileFilterOne, operator, fileFilterTwo))); + } + + public static FileFilter and(FileFilter... fileFilters) { + return and(Arrays.asList(nullSafeArray(fileFilters, FileFilter.class))); + } + + public static FileFilter and(Iterable fileFilters) { + FileFilter current = null; + + for (FileFilter fileFilter : nullSafeIterable(fileFilters)) { + current = compose(current, LogicalOperator.AND, fileFilter); + } + + return current; + } + + public static FileFilter or(FileFilter... fileFilters) { + return or(Arrays.asList(nullSafeArray(fileFilters, FileFilter.class))); + } + + public static FileFilter or(Iterable fileFilters) { + FileFilter current = null; + + for (FileFilter fileFilter : nullSafeIterable(fileFilters)) { + current = compose(current, LogicalOperator.OR, fileFilter); + } + + return current; + } @Override - public boolean accept(final File pathname) { - return (pathname != null && pathname.isFile()); + public boolean accept(File pathname) { + switch (this.logicalOperator) { + case AND: + return (fileFilterOne.accept(pathname) && fileFilterTwo.accept(pathname)); + case OR: + return (fileFilterOne.accept(pathname) || fileFilterTwo.accept(pathname)); + default: + throw new UnsupportedOperationException(String.format( + "Logical operator [%s] is unsupported", this.logicalOperator)); + } + } + + enum LogicalOperator { + AND, OR; } } - public static final class DirectoryOnlyFilter implements FileFilter { + public static class DirectoryOnlyFilter implements FileFilter { public static final DirectoryOnlyFilter INSTANCE = new DirectoryOnlyFilter(); @Override - public boolean accept(final File pathname) { - return (pathname != null && pathname.isDirectory()); + public boolean accept(File pathname) { + return isDirectory(pathname); + } + } + + public static final class FileExtensionFilter extends FileOnlyFilter { + + private final String fileExtension; + + public static FileExtensionFilter newFileExtensionFilter(String fileExtension) { + return new FileExtensionFilter(fileExtension); + } + + public FileExtensionFilter(String fileExtension) { + Assert.hasText(fileExtension, String.format("File extension [%s] must be specified", fileExtension)); + this.fileExtension = fileExtension; + } + + @Override + public boolean accept(File pathname) { + return (super.accept(pathname) && pathname.getAbsolutePath().toLowerCase().endsWith(this.fileExtension)); + } + } + + public static class FileOnlyFilter implements FileFilter { + + public static final FileOnlyFilter INSTANCE = new FileOnlyFilter(); + + @Override + public boolean accept(File pathname) { + return isFile(pathname); + } + } + + public static class NegatingFileFilter implements FileFilter { + + private final FileFilter delegate; + + public static NegatingFileFilter newNegatingFileFilter(FileFilter delegate) { + return new NegatingFileFilter(delegate); + } + + public NegatingFileFilter(FileFilter delegate) { + Assert.notNull(delegate, "FileFilter must not be null"); + this.delegate = delegate; + } + + @Override + public boolean accept(File pathname) { + return !this.delegate.accept(pathname); } } } diff --git a/src/test/java/org/springframework/data/gemfire/test/support/FileUtils.java b/src/test/java/org/springframework/data/gemfire/test/support/FileUtils.java index 4a4fe0da..aa1388c6 100644 --- a/src/test/java/org/springframework/data/gemfire/test/support/FileUtils.java +++ b/src/test/java/org/springframework/data/gemfire/test/support/FileUtils.java @@ -1,5 +1,5 @@ /* - * Copyright 2010-2013 the original author or authors. + * Copyright 2010-2017 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -27,7 +27,8 @@ import org.springframework.util.Assert; import org.springframework.util.StringUtils; /** - * The FileUtils class is a utility class for processing files, working with java.io.File objects. + * The {@link FileUtils} class is an abstract utility class for processing file system files + * by working with {@link File} objects. * * @author John Blum * @see java.io.File @@ -39,20 +40,33 @@ import org.springframework.util.StringUtils; @SuppressWarnings("unused") public abstract class FileUtils extends IOUtils { + public static final String FILE_SEPARATOR = System.getProperty("file.separator"); public static final String LINE_SEPARATOR = System.getProperty("line.separator"); - public static boolean isDirectory(final File path) { + /* (non-Javadoc) */ + public static boolean isDirectory(File path) { return (path != null && path.isDirectory()); } - public static boolean isFile(final File path) { + /* (non-Javadoc) */ + public static boolean isFile(File path) { return (path != null && path.isFile()); } + /* (non-Javadoc) */ + public static File newFile(String pathname) { + return new File(pathname); + } + + /* (non-Javadoc) */ + public static File newFile(File parent, String pathname) { + return new File(parent, pathname); + } + + /* (non-Javadoc) */ @SuppressWarnings("all") public static String read(File file) throws IOException { - Assert.isTrue(isFile(file), String.format( - "File [%1$s], from which to read the contents of, does not refer to a valid file", file)); + Assert.isTrue(isFile(file), String.format("The file [%s] to read the contents from is not a valid file", file)); BufferedReader fileReader = new BufferedReader(new FileReader(file)); @@ -71,8 +85,9 @@ public abstract class FileUtils extends IOUtils { } } + /* (non-Javadoc) */ public static void write(File file, String contents) throws IOException { - Assert.notNull(file, "File must not be null!"); + Assert.notNull(file, "File must not be null"); Assert.isTrue(StringUtils.hasText(contents), String.format( "The contents for File [%1$s] cannot be null or empty", file)); @@ -88,5 +103,4 @@ public abstract class FileUtils extends IOUtils { IOUtils.close(fileWriter); } } - } diff --git a/src/test/java/org/springframework/data/gemfire/test/support/IOUtils.java b/src/test/java/org/springframework/data/gemfire/test/support/IOUtils.java index 4c18319d..b439fec4 100644 --- a/src/test/java/org/springframework/data/gemfire/test/support/IOUtils.java +++ b/src/test/java/org/springframework/data/gemfire/test/support/IOUtils.java @@ -1,5 +1,5 @@ /* - * Copyright 2010-2013 the original author or authors. + * Copyright 2010-2017 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -22,9 +22,10 @@ import java.util.logging.Level; import java.util.logging.Logger; /** - * The IOUtils class is an utility class working with IO operations. + * The {@link IOUtils} class is an abstract utility class for working with IO operations. * * @author John Blum + * @see java.io.Closeable * @since 1.5.0 */ @SuppressWarnings("unused") @@ -32,6 +33,7 @@ public abstract class IOUtils { protected static final Logger log = Logger.getLogger(IOUtils.class.getName()); + /* (non-Javadoc) */ public static boolean close(Closeable closeable) { if (closeable != null) { try { @@ -48,5 +50,4 @@ public abstract class IOUtils { return false; } - }