TestIOUtils.java

/*
 * Copyright (c) 2011, Cloudera, Inc. All Rights Reserved.
 *
 * Cloudera, Inc. 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
 *
 * This software 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 com.cloudera.lib.io;

import com.cloudera.circus.test.TestDir;
import com.cloudera.circus.test.XTest;
import org.testng.Assert;
import org.testng.annotations.DataProvider;
import org.testng.annotations.Test;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.io.StringReader;
import java.io.StringWriter;
import java.util.HashSet;
import java.util.Set;
import java.util.zip.ZipEntry;
import java.util.zip.ZipInputStream;
import java.util.zip.ZipOutputStream;

public class TestIOUtils extends XTest {

  @Test(expectedExceptions = IllegalArgumentException.class)
  public void deleteTooShort() throws IOException {
    IOUtils.delete(new File("/xxx"));
  }

  @Test
  @TestDir
  public void delete() throws IOException {
    File file = new File(getTestDir(), "xxx");
    new FileOutputStream(file).close();
    IOUtils.delete(file);
    Assert.assertFalse(file.exists());

    File dir = new File(getTestDir(), "foo");
    File subdir = new File(dir, "bar");
    File subsubdir = new File(subdir, "woo");
    file = new File(subdir, "file");
    Assert.assertTrue(subsubdir.mkdirs());
    new FileOutputStream(file).close();
    IOUtils.delete(dir);
    Assert.assertFalse(dir.exists());
  }

  private byte[] createByteArray(int len, int offset, int trim) {
    byte[] arr = new byte[len];
    for (int i = 0; i < len; i++) {
      arr[i] = (byte) (i % 255);
    }
    byte[] trimmed = new byte[trim];
    System.arraycopy(arr, offset, trimmed, 0, trim);
    return trimmed;
  }

  @DataProvider(name = "copyByteStream")
  public Object[][] copyByteStreamParams() {
    return new Object[][]{
      {createByteArray(10, 0, 10), -1L, -1L, createByteArray(10, 0, 10)},
      {createByteArray(10, 0, 10), 2L, 5L, createByteArray(10, 2, 5)},
      {createByteArray(1100, 0, 1100), -1L, -1L, createByteArray(1100, 0, 1100)},
      {createByteArray(1100, 0, 1100), 0L, 1100L, createByteArray(1100, 0, 1100)},
      {createByteArray(1100, 0, 1100), 0L, 1099L, createByteArray(1100, 0, 1099)},
      {createByteArray(1100, 0, 1100), 0L, 1101L, createByteArray(1100, 0, 1100)},
    };
  }

  @Test(dataProvider = "copyByteStream")
  public void copyByteStream(byte[] data, long offset, long len, byte[] expected) throws IOException {

    ByteArrayInputStream is = new ByteArrayInputStream(data);
    ByteArrayOutputStream os = new ByteArrayOutputStream();
    if (offset == -1) {
      IOUtils.copy(is, os);
    }
    else {
      IOUtils.copy(is, os, offset, len);
    }
    os.close();
    Assert.assertEquals(os.toByteArray(), expected);
  }

  @Test(expectedExceptions = IOException.class)
  public void copyByteStreamPastEOF() throws IOException {
    byte[] data = "0123456789".getBytes();
    ByteArrayInputStream is = new ByteArrayInputStream(data);
    ByteArrayOutputStream os = new ByteArrayOutputStream();
    IOUtils.copy(is, os, 20, 5);
  }


  private char[] createCharArray(int len, int offset, int trim) {
    char[] arr = new char[len];
    for (int i = 0; i < len; i++) {
      arr[i] = (char) (i % 255);
    }
    char[] trimmed = new char[trim];
    System.arraycopy(arr, offset, trimmed, 0, trim);
    return trimmed;
  }

  @DataProvider(name = "copyCharStream")
  public Object[][] copyCharStreamParams() {
    return new Object[][]{
      {createCharArray(10, 0, 10), -1L, -1L, createCharArray(10, 0, 10)},
      {createCharArray(10, 0, 10), 2L, 5L, createCharArray(10, 2, 5)},
      {createCharArray(1100, 0, 1100), -1L, -1L, createCharArray(1100, 0, 1100)},
      {createCharArray(1100, 0, 1100), 0L, 1100L, createCharArray(1100, 0, 1100)},
      {createCharArray(1100, 0, 1100), 0L, 1099L, createCharArray(1100, 0, 1099)},
      {createCharArray(1100, 0, 1100), 0L, 1101L, createCharArray(1100, 0, 1100)},
    };
  }

  @Test(dataProvider = "copyCharStream")
  public void copyCharStream(char[] data, long offset, long len, char[] expected) throws IOException {
    StringReader reader = new StringReader(new String(data));
    StringWriter writer = new StringWriter();
    if (offset == -1) {
      IOUtils.copy(reader, writer);
    }
    else {
      IOUtils.copy(reader, writer, offset, len);
    }
    writer.close();
    Assert.assertEquals(writer.toString(), new String(expected));
  }

  @Test(expectedExceptions = IOException.class)
  public void copyCharStreamPastEOF() throws IOException {
    String data = "0123456789";
    StringReader reader = new StringReader(data);
    StringWriter writer = new StringWriter();
    IOUtils.copy(reader, writer, 20, 5);
  }

  @Test
  public void ListToString() throws IOException {
    String data = "0123456789";
    StringReader is = new StringReader(data);
    String str = IOUtils.toString(is);
    Assert.assertEquals(str, data);
  }

  @DataProvider(name = "zip")
  public Object[][] zipParams() {
    return new Object[][]{{""}, {"foo/"}};
  }

  @Test(dataProvider = "zip")
  @TestDir
  public void zip(String base) throws IOException {

    File dir = getTestDir();
    File subdir = new File(dir, "bar");
    File subsubdir = new File(subdir, "woo");
    File file = new File(subdir, "file");
    Assert.assertTrue(subsubdir.mkdirs());
    OutputStream os = new FileOutputStream(file);
    os.write('a');
    os.close();

    Set<String> contents = new HashSet<String>();
    contents.add(base + "bar/woo/");
    contents.add(base + "bar/file");

    ByteArrayOutputStream baos = new ByteArrayOutputStream();
    ZipOutputStream zos = new ZipOutputStream(baos);
    IOUtils.zipDir(dir, base, zos);
    ZipInputStream zis = new ZipInputStream(new ByteArrayInputStream(baos.toByteArray()));
    Set<String> zipContents = new HashSet<String>();
    ZipEntry entry = zis.getNextEntry();
    while (entry != null) {
      zipContents.add(entry.getName());
      entry = zis.getNextEntry();
    }
    Assert.assertEquals(zipContents, contents);
  }

}