• Home
• io.snappydata
• gemfire-junit
• 1.5.3
• source code
• IOUtilsTest.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

com.gemstone.gemfire.internal.util.IOUtilsTest Maven / Gradle / Ivy

/*
 * Copyright (c) 2010-2015 Pivotal Software, Inc. All rights reserved.
 *
 * Licensed 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. See accompanying
 * LICENSE file.
 */
package com.gemstone.gemfire.internal.util;

import static org.junit.Assert.*;

import java.io.ByteArrayInputStream;
import java.io.Closeable;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.math.BigDecimal;
import java.util.Calendar;

import org.jmock.Expectations;
import org.jmock.Mockery;
import org.jmock.lib.legacy.ClassImposteriser;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

/**
 * Test class for testing the contract and functionality of the IOUtils class.
 * 

 * @see com.gemstone.gemfire.internal.util.IOUtils
 * @see org.jmock.Expectations
 * @see org.jmock.Mockery
 * @see org.junit.Assert
 * @see org.junit.Test
 */
public class IOUtilsTest {

  private Mockery mockContext;

  @Before
  public void setup() {
    mockContext = new Mockery() {{
      setImposteriser(ClassImposteriser.INSTANCE);
    }};
  }

  @After
  public void tearDown() {
    mockContext.assertIsSatisfied();
    mockContext = null;
  }

  /**
   * Gets a fully-qualified path anchored at root.
   * 

   * @param pathElements a String array containing the elements of the path.
   * @return a fully-qualified pathname as a String value.
   */
  protected String toPathname(final String... pathElements) {
    if (pathElements != null) {
      final StringBuilder buffer = new StringBuilder();
      for (String pathElement : pathElements) {
        buffer.append(File.separator);
        buffer.append(pathElement);
      }
      return buffer.toString();
    }

    return null;
  }

  @Test
  public void testAppendToPath() {
    assertEquals(null, IOUtils.appendToPath(null, (String[]) null));
    assertEquals(File.separator, IOUtils.appendToPath(null));
    assertEquals(File.separator, IOUtils.appendToPath(""));
    assertEquals(File.separator, IOUtils.appendToPath(" "));
    assertEquals(File.separator, IOUtils.appendToPath(File.separator));
    assertEquals(toPathname("bin", "a.out"), IOUtils.appendToPath(null, "bin", "a.out"));
    assertEquals(toPathname("bin", "a.out"), IOUtils.appendToPath(File.separator, "bin", "a.out"));
    assertEquals(toPathname("usr", "local", "bin", "a.out"), IOUtils
      .appendToPath(toPathname("usr", "local"), "bin", "a.out"));
  }

  @Test
  public void testClose() throws IOException {
    final Closeable mockCloseable = mockContext.mock(Closeable.class, "Closeable");

    mockContext.checking(new Expectations() {{
      oneOf(mockCloseable).close();
    }});

    IOUtils.close(mockCloseable);
  }

  @Test
  public void testCloseIgnoresIOException() throws IOException {
    final Closeable mockCloseable = mockContext.mock(Closeable.class, "Closeable");

    mockContext.checking(new Expectations() {{
      oneOf(mockCloseable).close();
      will(throwException(new IOException("test")));
    }});

    try {
      IOUtils.close(mockCloseable);
    }
    catch (Throwable unexpected) {
      if (unexpected instanceof IOException) {
        fail("Calling close on a Closeable object unexpectedly threw an IOException!");
      }
    }
  }

  @Test
  public void testCreatePath() {
    assertEquals("", IOUtils.createPath());
    assertEquals("/path/to/file.test".replace("/", File.separator), IOUtils.createPath("path", "to", "file.test"));
    assertEquals("/path/to/a/directory".replace("/", File.separator), IOUtils.createPath("path", "to", "a", "directory"));
  }

  @Test
  public void testCreatePathWithSeparator() {
    assertEquals("", IOUtils.createPath(new String[0], "-"));
    assertEquals("-path-to-file.ext".replace("/", File.separator), IOUtils.createPath(new String[] {
      "path",
      "to",
      "file.ext"
    }, "-"));
    assertEquals("-path-to-a-directory", IOUtils.createPath(new String[] { "path", "to", "a", "directory" }, "-"));
  }

  @Test
  public void testGetFilename() {
    assertNull(IOUtils.getFilename(null));
    assertEquals("", IOUtils.getFilename(""));
    assertEquals("  ", IOUtils.getFilename("  "));
    assertEquals("", IOUtils.getFilename(File.separator));
    assertEquals("a.ext", IOUtils.getFilename("a.ext"));
    assertEquals("b.ext", IOUtils.getFilename(toPathname("b.ext")));
    assertEquals("c.ext", IOUtils.getFilename(toPathname("path", "to", "c.ext")));
    assertEquals("filename.ext", IOUtils.getFilename(toPathname("export", "path", "to", "some", "filename.ext")));
    assertEquals("", IOUtils.getFilename(toPathname("path", "to", "a", "directory") + File.separator));
  }

  @Test
  public void testIsExistingPathname() {
    assertTrue(IOUtils.isExistingPathname(System.getProperty("java.home")));
    assertTrue(IOUtils.isExistingPathname(System.getProperty("user.home")));
    assertFalse(IOUtils.isExistingPathname("/path/to/non_existing/directory/"));
    assertFalse(IOUtils.isExistingPathname("/path/to/non_existing/file.ext"));
  }

  @Test
  public void testObjectSerialization() throws IOException, ClassNotFoundException {
    final Calendar now = Calendar.getInstance();

    assertNotNull(now);

    final byte[] nowBytes = IOUtils.serializeObject(now);

    assertNotNull(nowBytes);
    assertTrue(nowBytes.length != 0);

    final Object nowObj = IOUtils.deserializeObject(nowBytes);

    assertTrue(nowObj instanceof Calendar);
    assertEquals(now.getTimeInMillis(), ((Calendar) nowObj).getTimeInMillis());
  }

  @Test
  public void testObjectSerializationWithClassLoader() throws IOException, ClassNotFoundException {
    final BigDecimal pi = new BigDecimal(Math.PI);

    final byte[] piBytes = IOUtils.serializeObject(pi);

    assertNotNull(piBytes);
    assertTrue(piBytes.length != 0);

    final Object piObj = IOUtils.deserializeObject(piBytes, IOUtilsTest.class.getClassLoader());

    assertTrue(piObj instanceof BigDecimal);
    assertEquals(pi, piObj);
  }

  @Test
  public void testToByteArray() throws IOException {
    final byte[] expected = new byte[] { (byte) 0xCA, (byte) 0xFE, (byte) 0xBA, (byte) 0xBE };

    final byte[] actual = IOUtils.toByteArray(new ByteArrayInputStream(expected));

    assertNotNull(actual);
    assertEquals(expected.length, actual.length);

    for (int index = 0; index < actual.length; index++) {
      assertEquals(expected[index], actual[index]);
    }
  }

  @Test(expected = IOException.class)
  public void testToByteArrayThrowsIOException() throws IOException {
    final InputStream mockIn = mockContext.mock(InputStream.class, "testToByteArrayThrowsIOException");

    mockContext.checking(new Expectations() {{
      oneOf(mockIn).read(with(aNonNull(byte[].class)));
      will(throwException(new IOException("test")));
      oneOf(mockIn).close();
    }});

    IOUtils.toByteArray(mockIn);
  }

  @Test(expected = AssertionError.class)
  public void testToByteArrayWithNull() throws IOException {
    try {
      IOUtils.toByteArray(null);
    }
    catch (AssertionError expected) {
      assertEquals("The input stream to read bytes from cannot be null!", expected.getMessage());
      throw expected;
    }
  }

  @Test
  public void testTryGetCanonicalFileElseGetAbsoluteFile() throws Exception {
    final MockFile file = (MockFile) IOUtils.tryGetCanonicalFileElseGetAbsoluteFile(
      new MockFile("/path/to/non_existing/file.test", null));

    assertNotNull(file);
    assertFalse(file.exists());
    assertTrue(file.isGetCanonicalFileCalled());
    assertFalse(file.isGetAbsoluteFileCalled());
  }

  @Test
  public void testTryGetCanonicalFileElseGetAbsoluteFileHandlesIOException() throws Exception {
    final MockFile file = (MockFile) IOUtils.tryGetCanonicalFileElseGetAbsoluteFile(
      new MockFile(System.getProperty("user.home"), new IOException("test")));

    assertNotNull(file);
    assertTrue(file.exists());
    assertTrue(file.isGetCanonicalFileCalled());
    assertTrue(file.isGetAbsoluteFileCalled());
  }

  @Test
  public void testVerifyPathnameExists() throws FileNotFoundException {
    assertEquals(System.getProperty("java.io.tmpdir"), IOUtils.verifyPathnameExists(
      System.getProperty("java.io.tmpdir")));
  }

  @Test(expected = FileNotFoundException.class)
  public void testVerifyPathnameExistsWithNonExistingPathname() throws FileNotFoundException {
    try {
      IOUtils.verifyPathnameExists("/path/to/non_existing/file.test");
    }
    catch (FileNotFoundException expected) {
      assertEquals("Pathname (/path/to/non_existing/file.test) could not be found!", expected.getMessage());
      throw expected;
    }
  }

  protected static final class MockFile extends File {

    private boolean isGetAbsoluteFileCalled = false;
    private boolean isGetCanonicalFileCalled = false;

    private final IOException e;

    public MockFile(final String pathname, IOException e) {
      super(pathname);
      this.e = e;
    }

    @Override
    public File getAbsoluteFile() {
      isGetAbsoluteFileCalled = true;
      return this;
    }

    protected boolean isGetAbsoluteFileCalled() {
      return isGetAbsoluteFileCalled;
    }

    @Override
    public File getCanonicalFile() throws IOException {
      isGetCanonicalFileCalled = true;

      if (e != null) {
        throw e;
      }

      return this;
    }

    protected boolean isGetCanonicalFileCalled() {
      return isGetCanonicalFileCalled;
    }
  }

}