/*
 * Copyright (C) 2012 The Guava Authors
 *
 * 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.
 */

package com.google.common.io;

import static com.google.common.io.SourceSinkFactory.ByteSourceFactory;
import static com.google.common.io.SourceSinkFactory.CharSourceFactory;
import static org.junit.Assert.assertArrayEquals;

import com.google.common.base.Charsets;
import com.google.common.base.Optional;
import com.google.common.collect.ImmutableList;
import com.google.common.hash.HashCode;
import com.google.common.hash.Hashing;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.lang.reflect.Method;
import java.util.Map.Entry;
import java.util.Random;
import junit.framework.TestSuite;

/**
 * A generator of {@code TestSuite} instances for testing {@code ByteSource} implementations.
 * Generates tests of a all methods on a {@code ByteSource} given various inputs the source is
 * expected to contain as well as as sub-suites for testing the {@code CharSource} view and {@code
 * slice()} views in the same way.
 *
 * @author Colin Decker
 */
@AndroidIncompatible // Android doesn't understand tests that lack default constructors.
public class ByteSourceTester extends SourceSinkTester<ByteSource, byte[], ByteSourceFactory> {

  private static final ImmutableList<Method> testMethods = getTestMethods(ByteSourceTester.class);

  static TestSuite tests(String name, ByteSourceFactory factory, boolean testAsCharSource) {
    TestSuite suite = new TestSuite(name);
    for (Entry<String, String> entry : TEST_STRINGS.entrySet()) {
      if (testAsCharSource) {
        suite.addTest(suiteForString(factory, entry.getValue(), name, entry.getKey()));
      } else {
        suite.addTest(
            suiteForBytes(
                factory, entry.getValue().getBytes(Charsets.UTF_8), name, entry.getKey(), true));
      }
    }
    return suite;
  }

  static TestSuite suiteForString(
      ByteSourceFactory factory, String string, String name, String desc) {
    TestSuite suite = suiteForBytes(factory, string.getBytes(Charsets.UTF_8), name, desc, true);
    CharSourceFactory charSourceFactory = SourceSinkFactories.asCharSourceFactory(factory);
    suite.addTest(
        CharSourceTester.suiteForString(
            charSourceFactory, string, name + ".asCharSource[Charset]", desc));
    return suite;
  }

  static TestSuite suiteForBytes(
      ByteSourceFactory factory, byte[] bytes, String name, String desc, boolean slice) {
    TestSuite suite = new TestSuite(name + " [" + desc + "]");
    for (Method method : testMethods) {
      suite.addTest(new ByteSourceTester(factory, bytes, name, desc, method));
    }

    if (slice && bytes.length > 0) {
      // test a random slice() of the ByteSource
      Random random = new Random();
      byte[] expected = factory.getExpected(bytes);
      // if expected.length == 0, off has to be 0 but length doesn't matter--result will be empty
      int off = expected.length == 0 ? 0 : random.nextInt(expected.length);
      int len = expected.length == 0 ? 4 : random.nextInt(expected.length - off);

      ByteSourceFactory sliced = SourceSinkFactories.asSlicedByteSourceFactory(factory, off, len);
      suite.addTest(suiteForBytes(sliced, bytes, name + ".slice[long, long]", desc, false));

      // test a slice() of the ByteSource starting at a random offset with a length of
      // Long.MAX_VALUE
      ByteSourceFactory slicedLongMaxValue =
          SourceSinkFactories.asSlicedByteSourceFactory(factory, off, Long.MAX_VALUE);
      suite.addTest(
          suiteForBytes(
              slicedLongMaxValue, bytes, name + ".slice[long, Long.MAX_VALUE]", desc, false));

      // test a slice() of the ByteSource starting at an offset greater than its size
      ByteSourceFactory slicedOffsetPastEnd =
          SourceSinkFactories.asSlicedByteSourceFactory(
              factory, expected.length + 2, expected.length + 10);
      suite.addTest(
          suiteForBytes(slicedOffsetPastEnd, bytes, name + ".slice[size + 2, long]", desc, false));
    }

    return suite;
  }

  private ByteSource source;

  public ByteSourceTester(
      ByteSourceFactory factory, byte[] bytes, String suiteName, String caseDesc, Method method) {
    super(factory, bytes, suiteName, caseDesc, method);
  }

  @Override
  public void setUp() throws IOException {
    source = factory.createSource(data);
  }

  public void testOpenStream() throws IOException {
    InputStream in = source.openStream();
    try {
      byte[] readBytes = ByteStreams.toByteArray(in);
      assertExpectedBytes(readBytes);
    } finally {
      in.close();
    }
  }

  public void testOpenBufferedStream() throws IOException {
    InputStream in = source.openBufferedStream();
    try {
      byte[] readBytes = ByteStreams.toByteArray(in);
      assertExpectedBytes(readBytes);
    } finally {
      in.close();
    }
  }

  public void testRead() throws IOException {
    byte[] readBytes = source.read();
    assertExpectedBytes(readBytes);
  }

  public void testCopyTo_outputStream() throws IOException {
    ByteArrayOutputStream out = new ByteArrayOutputStream();
    source.copyTo(out);
    assertExpectedBytes(out.toByteArray());
  }

  public void testCopyTo_byteSink() throws IOException {
    final ByteArrayOutputStream out = new ByteArrayOutputStream();
    // HERESY! but it's ok just for this I guess
    source.copyTo(
        new ByteSink() {
          @Override
          public OutputStream openStream() throws IOException {
            return out;
          }
        });
    assertExpectedBytes(out.toByteArray());
  }

  public void testIsEmpty() throws IOException {
    assertEquals(expected.length == 0, source.isEmpty());
  }

  public void testSize() throws IOException {
    assertEquals(expected.length, source.size());
  }

  public void testSizeIfKnown() throws IOException {
    Optional<Long> sizeIfKnown = source.sizeIfKnown();
    if (sizeIfKnown.isPresent()) {
      assertEquals(expected.length, (long) sizeIfKnown.get());
    }
  }

  public void testContentEquals() throws IOException {
    assertTrue(
        source.contentEquals(
            new ByteSource() {
              @Override
              public InputStream openStream() throws IOException {
                return new RandomAmountInputStream(
                    new ByteArrayInputStream(expected), new Random());
              }
            }));
  }

  public void testRead_usingByteProcessor() throws IOException {
    byte[] readBytes =
        source.read(
            new ByteProcessor<byte[]>() {
              final ByteArrayOutputStream out = new ByteArrayOutputStream();

              @Override
              public boolean processBytes(byte[] buf, int off, int len) throws IOException {
                out.write(buf, off, len);
                return true;
              }

              @Override
              public byte[] getResult() {
                return out.toByteArray();
              }
            });

    assertExpectedBytes(readBytes);
  }

  public void testHash() throws IOException {
    HashCode expectedHash = Hashing.md5().hashBytes(expected);
    assertEquals(expectedHash, source.hash(Hashing.md5()));
  }

  public void testSlice_illegalArguments() {
    try {
      source.slice(-1, 0);
      fail("expected IllegalArgumentException for call to slice with offset -1: " + source);
    } catch (IllegalArgumentException expected) {
    }

    try {
      source.slice(0, -1);
      fail("expected IllegalArgumentException for call to slice with length -1: " + source);
    } catch (IllegalArgumentException expected) {
    }
  }

  // Test that you can not expand the readable data in a previously sliced ByteSource.
  public void testSlice_constrainedRange() throws IOException {
    long size = source.read().length;
    if (size >= 2) {
      ByteSource sliced = source.slice(1, size - 2);
      assertEquals(size - 2, sliced.read().length);
      ByteSource resliced = sliced.slice(0, size - 1);
      assertTrue(sliced.contentEquals(resliced));
    }
  }

  private void assertExpectedBytes(byte[] readBytes) {
    assertArrayEquals(expected, readBytes);
  }
}
