Java FileHelper.writeStringAsFile方法代码示例

import org.apache.metamodel.util.FileHelper; //导入方法依赖的package包/类
@Test
public void testWriteAndReadAllStringPatterns() throws Exception {
    configurationWriter.externalize(new SimpleStringPattern("simple sp", "[email protected]"));
    configurationWriter.externalize(new RegexStringPattern("regex pattern", ".*", false));

    final String str = transform(configurationWriter.getDocument());
    final File file = new File("target/" + getClass().getSimpleName() + "-" + testName.getMethodName() + ".xml");
    FileHelper.writeStringAsFile(file, str);

    final DataCleanerConfiguration configuration = new JaxbConfigurationReader().create(file);
    assertEquals("[regex pattern, simple sp]",
            Arrays.toString(configuration.getReferenceDataCatalog().getStringPatternNames()));

    final SimpleStringPattern simpleStringPattern =
            (SimpleStringPattern) configuration.getReferenceDataCatalog().getStringPattern("simple sp");
    assertEquals("[email protected]", simpleStringPattern.getExpression());

    final RegexStringPattern regexStringPattern =
            (RegexStringPattern) configuration.getReferenceDataCatalog().getStringPattern("regex pattern");
    assertEquals(".*", regexStringPattern.getExpression());
    assertEquals(false, regexStringPattern.isMatchEntireString());
}
 

import org.apache.metamodel.util.FileHelper; //导入方法依赖的package包/类
public void testChangesInbetweenUsage() throws Exception {
    final File file = new File("target/TextBasedDictionaryTest-modification.txt");
    FileHelper.writeStringAsFile(file, "foo\nbar");

    final TextFileDictionary dict = new TextFileDictionary("dict", file.getPath(), "UTF-8");
    try (DictionaryConnection connection = dict.openConnection(configuration)) {
        assertTrue(connection.containsValue("foo"));
        assertTrue(connection.containsValue("bar"));
        assertFalse(connection.containsValue("foobar"));
    }

    FileHelper.writeStringAsFile(file, "foo\nfoobar");

    try (DictionaryConnection connection = dict.openConnection(configuration)) {
        assertTrue(connection.containsValue("foo"));
        assertFalse(connection.containsValue("bar"));
        assertTrue(connection.containsValue("foobar"));
    }
}
 

import org.apache.metamodel.util.FileHelper; //导入方法依赖的package包/类
public void testModificationsClearCache() throws Exception {
    final File file = new File("target/TextBasedSynonymCatalogTest-modification.txt");
    FileHelper.writeStringAsFile(file, "foo,fooo,fo\nbar,baar,br", "UTF-8");
    final SynonymCatalog cat = new TextFileSynonymCatalog("sc", file, true, "UTF-8");

    try (SynonymCatalogConnection scConnection = cat.openConnection(configuration)) {
        assertEquals("foo", scConnection.getMasterTerm("fooo"));
        assertEquals("bar", scConnection.getMasterTerm("br"));
        assertEquals(null, scConnection.getMasterTerm("foob"));
    }

    FileHelper.writeStringAsFile(file, "foo,fooo,fo\nfoobar,foob");

    try (SynonymCatalogConnection scConnection = cat.openConnection(configuration)) {
        assertEquals("foo", scConnection.getMasterTerm("fooo"));
        assertEquals(null, scConnection.getMasterTerm("br"));
        assertEquals("foobar", scConnection.getMasterTerm("foob"));
    }
}
 

import org.apache.metamodel.util.FileHelper; //导入方法依赖的package包/类
public void testModificationsClearCache() throws Exception {
	File file = new File("target/TextBasedDictionaryTest-modification.txt");
	FileHelper.writeStringAsFile(file, "foo\nbar");

	TextFileDictionary dict = new TextFileDictionary("dict", file.getPath(), "UTF-8");
	dict.init();
	assertTrue(dict.containsValue("foo"));
	assertTrue(dict.containsValue("bar"));
	assertFalse(dict.containsValue("foobar"));

	// sleep to make sure the file monitor will catch a file change
	Thread.sleep(2000);
	
	FileHelper.writeStringAsFile(file, "foo\nfoobar");
	dict.init();

	assertTrue(dict.containsValue("foo"));
	assertFalse(dict.containsValue("bar"));
	assertTrue(dict.containsValue("foobar"));
}
 

import org.apache.metamodel.util.FileHelper; //导入方法依赖的package包/类
public void testModificationsClearCache() throws Exception {
    File file = new File("target/TextBasedSynonymCatalogTest-modification.txt");
    FileHelper.writeStringAsFile(file, "foo,fooo,fo\nbar,baar,br");
    SynonymCatalog cat = new TextFileSynonymCatalog("sc", file, true, "UTF-8");
    assertEquals("foo", cat.getMasterTerm("fooo"));
    assertEquals("bar", cat.getMasterTerm("br"));
    assertEquals(null, cat.getMasterTerm("foob"));

    // sleep for two seconds because some filesystems only support
    // modification dating for the nearest second.
    Thread.sleep(2000);

    FileHelper.writeStringAsFile(file, "foo,fooo,fo\nfoobar,foob");
    assertEquals("foo", cat.getMasterTerm("fooo"));
    assertEquals(null, cat.getMasterTerm("br"));
    assertEquals("foobar", cat.getMasterTerm("foob"));
}
 

import org.apache.metamodel.util.FileHelper; //导入方法依赖的package包/类
@Test
public void testWriteAndReadAllDictionaries() throws Exception {
    configurationWriter.externalize(new SimpleDictionary("simple dict", false, "foo", "bar", "baz"));
    configurationWriter.externalize(new TextFileDictionary("textfile dict", "/foo/bar.txt", "UTF8", false));
    configurationWriter.externalize(new DatastoreDictionary("ds dict", "orderdb", "products.productname", false));

    final String str = transform(configurationWriter.getDocument());
    final File file = new File("target/" + getClass().getSimpleName() + "-" + testName.getMethodName() + ".xml");
    FileHelper.writeStringAsFile(file, str);

    final DataCleanerConfiguration configuration = new JaxbConfigurationReader().create(file);
    assertEquals("[ds dict, simple dict, textfile dict]",
            Arrays.toString(configuration.getReferenceDataCatalog().getDictionaryNames()));

    final SimpleDictionary simpleDictionary =
            (SimpleDictionary) configuration.getReferenceDataCatalog().getDictionary("simple dict");
    assertEquals(false, simpleDictionary.isCaseSensitive());
    assertEquals("[bar, baz, foo]",
            simpleDictionary.getValueSet().stream().sorted().collect(Collectors.toList()).toString());

    final TextFileDictionary textFileDictionary =
            (TextFileDictionary) configuration.getReferenceDataCatalog().getDictionary("textfile dict");
    assertEquals(false, textFileDictionary.isCaseSensitive());
    assertEquals("UTF8", textFileDictionary.getEncoding());
    assertTrue(textFileDictionary.getFilename().endsWith("bar.txt"));

    final DatastoreDictionary datastoreDictionary =
            (DatastoreDictionary) configuration.getReferenceDataCatalog().getDictionary("ds dict");
    assertEquals(false, datastoreDictionary.isLoadIntoMemory());
    assertEquals("orderdb", datastoreDictionary.getDatastoreName());
    assertEquals("products.productname", datastoreDictionary.getQualifiedColumnName());
}
 

import org.apache.metamodel.util.FileHelper; //导入方法依赖的package包/类
@Test
public void testWriteAndReadAllSynonymCatalogs() throws Exception {
    configurationWriter.externalize(new TextFileSynonymCatalog("textfile sc", "/foo/bar.txt", false, "UTF8"));
    configurationWriter.externalize(new DatastoreSynonymCatalog("ds sc", "orderdb", "products.productname",
            new String[] { "products.productline", "product.producttype" }, false));

    final String str = transform(configurationWriter.getDocument());
    final File file = new File("target/" + getClass().getSimpleName() + "-" + testName.getMethodName() + ".xml");
    FileHelper.writeStringAsFile(file, str);

    final DataCleanerConfiguration configuration = new JaxbConfigurationReader().create(file);
    assertEquals("[ds sc, textfile sc]",
            Arrays.toString(configuration.getReferenceDataCatalog().getSynonymCatalogNames()));

    final TextFileSynonymCatalog textFileSynonymCatalog =
            (TextFileSynonymCatalog) configuration.getReferenceDataCatalog().getSynonymCatalog("textfile sc");
    assertEquals("UTF8", textFileSynonymCatalog.getEncoding());
    assertTrue(textFileSynonymCatalog.getFilename().endsWith("bar.txt"));

    final DatastoreSynonymCatalog datastoreSynonymCatalog =
            (DatastoreSynonymCatalog) configuration.getReferenceDataCatalog().getSynonymCatalog("ds sc");
    assertEquals(false, datastoreSynonymCatalog.isLoadIntoMemory());
    assertEquals("orderdb", datastoreSynonymCatalog.getDatastoreName());
    assertEquals("products.productname", datastoreSynonymCatalog.getMasterTermColumnPath());
    assertEquals("[products.productline, product.producttype]",
            Arrays.toString(datastoreSynonymCatalog.getSynonymColumnPaths()));
}
 

import org.apache.metamodel.util.FileHelper; //导入方法依赖的package包/类
@Test
public void testWriteAndReadAllServers() throws Exception {
    configurationWriter
            .externalize(new EnvironmentBasedHadoopClusterInformation("environment", "Environment-based cluster"));
    configurationWriter.externalize(
            new DirectoryBasedHadoopClusterInformation("directory", "Directory-based cluster", "C:\\Users\\Test",
                    "file:///C:/Users/Test2"));
    configurationWriter.externalize(
            new DirectConnectionHadoopClusterInformation("namenode", "Namenode-based cluster",
                    URI.create("hdfs://localhost:8020/")));

    final String str = transform(configurationWriter.getDocument());

    // "Default" hadoop cluster reference should never be written
    assertFalse(str.contains(HadoopResource.DEFAULT_CLUSTERREFERENCE));

    final File file = new File("target/" + getClass().getSimpleName() + "-" + testName.getMethodName() + ".xml");
    FileHelper.writeStringAsFile(file, str);

    final DataCleanerConfiguration configuration = new JaxbConfigurationReader().create(file);
    final ServerInformationCatalog serverInformationCatalog = configuration.getServerInformationCatalog();
    assertEquals("[directory, environment, namenode, org.datacleaner.hadoop.environment]",
            Arrays.toString(serverInformationCatalog.getServerNames()));

    assertNotNull(serverInformationCatalog.getServer("environment"));

    final DirectoryBasedHadoopClusterInformation directoryBasedHadoopClusterInformation =
            (DirectoryBasedHadoopClusterInformation) serverInformationCatalog.getServer("directory");
    assertArrayEquals(new String[] { "C:\\Users\\Test", "file:///C:/Users/Test2" },
            directoryBasedHadoopClusterInformation.getDirectories());

    final DirectConnectionHadoopClusterInformation directConnectionHadoopClusterInformation =
            (DirectConnectionHadoopClusterInformation) serverInformationCatalog.getServer("namenode");
    assertEquals(URI.create("hdfs://localhost:8020/"), directConnectionHadoopClusterInformation.getNameNodeUri());

    configurationWriter.removeHadoopClusterServerInformation("namenode");

    final String str2 = transform(configurationWriter.getDocument());
    assertFalse(str2, str2.contains("namenode"));
}
 

import org.apache.metamodel.util.FileHelper; //导入方法依赖的package包/类
@Test
public void testWriteAndReadHadoopResourceDatastore() throws Exception {
    final MockHadoopConfigHelper helper = new MockHadoopConfigHelper(_temporaryFolder);

    helper.generateCoreFile();
    // Prepare "environment"
    try {
        System.setProperty(EnvironmentBasedHadoopClusterInformation.HADOOP_CONF_DIR,
                helper.getConfFolder().getAbsolutePath());

        final HadoopResource hadoopResource =
                new HadoopResource(URI.create("example-dates.csv"), new Configuration(),
                        HadoopResource.DEFAULT_CLUSTERREFERENCE);
        configurationWriter.externalize(new CsvDatastore("csvDatastore", hadoopResource));
        final String str = transform(configurationWriter.getDocument());
        final File file =
                new File("target/" + getClass().getSimpleName() + "-" + testName.getMethodName() + ".xml");
        FileHelper.writeStringAsFile(file, str);

        final DataCleanerConfiguration configuration = new JaxbConfigurationReader().create(file);

        final CsvDatastore csvDatastore =
                (CsvDatastore) configuration.getDatastoreCatalog().getDatastore("csvDatastore");
        final HadoopResource resource = (HadoopResource) csvDatastore.getResource();
        assertNotNull(resource);
        assertEquals("example-dates.csv", resource.getFilepath());
        assertEquals(helper.getPath(), resource.getHadoopConfiguration().get("fs.defaultFS"));
    } finally {
        System.clearProperty(EnvironmentBasedHadoopClusterInformation.HADOOP_CONF_DIR);
    }
}
 

import org.apache.metamodel.util.FileHelper; //导入方法依赖的package包/类
public static void save(String dataCleanerInstallationFolder) {
    final String pluginFolderPath = detectPluginFolderPath();
    final String configurationFilePath = pluginFolderPath + "/" + CONFIGURATION_FILENAME;

    final File file = new File(configurationFilePath);
    FileHelper.writeStringAsFile(file, dataCleanerInstallationFolder);
}