TestPseudoLocalFs.java
/**
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.hadoop.mapred.gridmix;
import static org.junit.Assert.*;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FileStatus;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;
import org.junit.Test;
/**
* Test the basic functionality of PseudoLocalFs
*/
public class TestPseudoLocalFs {
/**
* Test if a file on PseudoLocalFs of a specific size can be opened and read.
* Validate the size of the data read.
* Test the read methods of {@link PseudoLocalFs.RandomInputStream}.
* @throws Exception
*/
@Test
public void testPseudoLocalFsFileSize() throws Exception {
long fileSize = 10000;
Path path = PseudoLocalFs.generateFilePath("myPsedoFile", fileSize);
PseudoLocalFs pfs = new PseudoLocalFs();
pfs.create(path);
// Read 1 byte at a time and validate file size.
InputStream in = pfs.open(path, 0);
long totalSize = 0;
while (in.read() >= 0) {
++totalSize;
}
in.close();
assertEquals("File size mismatch with read().", fileSize, totalSize);
// Read data from PseudoLocalFs-based file into buffer to
// validate read(byte[]) and file size.
in = pfs.open(path, 0);
totalSize = 0;
byte[] b = new byte[1024];
int bytesRead = in.read(b);
while (bytesRead >= 0) {
totalSize += bytesRead;
bytesRead = in.read(b);
}
assertEquals("File size mismatch with read(byte[]).", fileSize, totalSize);
}
/**
* Validate if file status is obtained for correctly formed file paths on
* PseudoLocalFs and also verify if appropriate exception is thrown for
* invalid file paths.
* @param pfs Pseudo Local File System
* @param path file path for which getFileStatus() is to be called
* @param shouldSucceed <code>true</code> if getFileStatus() should succeed
* @throws IOException
*/
private void validateGetFileStatus(FileSystem pfs, Path path,
boolean shouldSucceed) throws IOException {
boolean expectedExceptionSeen = false;
FileStatus stat = null;
try {
stat = pfs.getFileStatus(path);
} catch(FileNotFoundException e) {
expectedExceptionSeen = true;
}
if (shouldSucceed) {
assertFalse("getFileStatus() has thrown Exception for valid file name "
+ path, expectedExceptionSeen);
assertNotNull("Missing file status for a valid file.", stat);
// validate fileSize
String[] parts = path.toUri().getPath().split("\\.");
long expectedFileSize = Long.parseLong(parts[parts.length - 1]);
assertEquals("Invalid file size.", expectedFileSize, stat.getLen());
} else {
assertTrue("getFileStatus() did not throw Exception for invalid file "
+ " name " + path, expectedExceptionSeen);
}
}
/**
* Validate if file creation succeeds for correctly formed file paths on
* PseudoLocalFs and also verify if appropriate exception is thrown for
* invalid file paths.
* @param pfs Pseudo Local File System
* @param path file path for which create() is to be called
* @param shouldSucceed <code>true</code> if create() should succeed
* @throws IOException
*/
private void validateCreate(FileSystem pfs, Path path,
boolean shouldSucceed) throws IOException {
boolean expectedExceptionSeen = false;
try {
pfs.create(path);
} catch(IOException e) {
expectedExceptionSeen = true;
}
if (shouldSucceed) {
assertFalse("create() has thrown Exception for valid file name "
+ path, expectedExceptionSeen);
} else {
assertTrue("create() did not throw Exception for invalid file name "
+ path, expectedExceptionSeen);
}
}
/**
* Validate if opening of file succeeds for correctly formed file paths on
* PseudoLocalFs and also verify if appropriate exception is thrown for
* invalid file paths.
* @param pfs Pseudo Local File System
* @param path file path for which open() is to be called
* @param shouldSucceed <code>true</code> if open() should succeed
* @throws IOException
*/
private void validateOpen(FileSystem pfs, Path path,
boolean shouldSucceed) throws IOException {
boolean expectedExceptionSeen = false;
try {
pfs.open(path);
} catch(IOException e) {
expectedExceptionSeen = true;
}
if (shouldSucceed) {
assertFalse("open() has thrown Exception for valid file name "
+ path, expectedExceptionSeen);
} else {
assertTrue("open() did not throw Exception for invalid file name "
+ path, expectedExceptionSeen);
}
}
/**
* Validate if exists() returns <code>true</code> for correctly formed file
* paths on PseudoLocalFs and returns <code>false</code> for improperly
* formed file paths.
* @param pfs Pseudo Local File System
* @param path file path for which exists() is to be called
* @param shouldSucceed expected return value of exists(<path>)
* @throws IOException
*/
private void validateExists(FileSystem pfs, Path path,
boolean shouldSucceed) throws IOException {
boolean ret = pfs.exists(path);
if (shouldSucceed) {
assertTrue("exists() returned false for valid file name " + path, ret);
} else {
assertFalse("exists() returned true for invalid file name " + path, ret);
}
}
/**
* Test Pseudo Local File System methods like getFileStatus(), create(),
* open(), exists() for <li> valid file paths and <li> invalid file paths.
* @throws IOException
*/
@Test
public void testPseudoLocalFsFileNames() throws IOException {
PseudoLocalFs pfs = new PseudoLocalFs();
Configuration conf = new Configuration();
conf.setClass("fs.pseudo.impl", PseudoLocalFs.class, FileSystem.class);
Path path = new Path("pseudo:///myPsedoFile.1234");
FileSystem testFs = path.getFileSystem(conf);
assertEquals("Failed to obtain a pseudo local file system object from path",
pfs.getUri().getScheme(), testFs.getUri().getScheme());
// Validate PseudoLocalFS operations on URI of some other file system
path = new Path("file:///myPsedoFile.12345");
validateGetFileStatus(pfs, path, false);
validateCreate(pfs, path, false);
validateOpen(pfs, path, false);
validateExists(pfs, path, false);
path = new Path("pseudo:///myPsedoFile");//.<fileSize> missing
validateGetFileStatus(pfs, path, false);
validateCreate(pfs, path, false);
validateOpen(pfs, path, false);
validateExists(pfs, path, false);
// thing after final '.' is not a number
path = new Path("pseudo:///myPsedoFile.txt");
validateGetFileStatus(pfs, path, false);
validateCreate(pfs, path, false);
validateOpen(pfs, path, false);
validateExists(pfs, path, false);
// Generate valid file name(relative path) and validate operations on it
long fileSize = 231456;
path = PseudoLocalFs.generateFilePath("my.Psedo.File", fileSize);
// Validate the above generateFilePath()
assertEquals("generateFilePath() failed.", fileSize,
pfs.validateFileNameFormat(path));
validateGetFileStatus(pfs, path, true);
validateCreate(pfs, path, true);
validateOpen(pfs, path, true);
validateExists(pfs, path, true);
// Validate operations on valid qualified path
path = new Path("myPsedoFile.1237");
path = pfs.makeQualified(path);
validateGetFileStatus(pfs, path, true);
validateCreate(pfs, path, true);
validateOpen(pfs, path, true);
validateExists(pfs, path, true);
}
}