// Copyright 2014 The Bazel Authors. 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.
package com.google.devtools.build.lib.vfs;

import static com.google.common.truth.Truth.assertThat;
import static com.google.common.truth.Truth.assertWithMessage;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;

import java.io.File;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;

/**
 * This class tests the functionality of the PathFragment.
 */
@RunWith(JUnit4.class)
public class PathFragmentWindowsTest {

  @Test
  public void testWindowsSeparator() {
    assertEquals("bar/baz", new PathFragment("bar\\baz").toString());
    assertEquals("C:/bar/baz", new PathFragment("c:\\bar\\baz").toString());
  }

  @Test
  public void testIsAbsoluteWindows() {
    assertTrue(new PathFragment("C:/").isAbsolute());
    assertTrue(new PathFragment("C:/").isAbsolute());
    assertTrue(new PathFragment("C:/foo").isAbsolute());
    assertTrue(new PathFragment("d:/foo/bar").isAbsolute());

    assertFalse(new PathFragment("*:/").isAbsolute());

    // C: is not an absolute path, it points to the current active directory on drive C:.
    assertFalse(new PathFragment("C:").isAbsolute());
    assertFalse(new PathFragment("C:foo").isAbsolute());
  }

  @Test
  public void testAbsoluteAndAbsoluteLookingPaths() {
    PathFragment p1 = new PathFragment("/c");
    assertThat(p1.isAbsolute()).isTrue();
    assertThat(p1.getDriveLetter()).isEqualTo('\0');
    assertThat(p1.getSegments()).containsExactly("c");

    PathFragment p2 = new PathFragment("/c/");
    assertThat(p2.isAbsolute()).isTrue();
    assertThat(p2.getDriveLetter()).isEqualTo('\0');
    assertThat(p2.getSegments()).containsExactly("c");

    PathFragment p3 = new PathFragment("C:/");
    assertThat(p3.isAbsolute()).isTrue();
    assertThat(p3.getDriveLetter()).isEqualTo('C');
    assertThat(p3.getSegments()).isEmpty();

    PathFragment p4 = new PathFragment("C:");
    assertThat(p4.isAbsolute()).isFalse();
    assertThat(p4.getDriveLetter()).isEqualTo('C');
    assertThat(p4.getSegments()).isEmpty();

    PathFragment p5 = new PathFragment("/c:");
    assertThat(p5.isAbsolute()).isTrue();
    assertThat(p5.getDriveLetter()).isEqualTo('\0');
    assertThat(p5.getSegments()).containsExactly("c:");

    assertThat(p1).isEqualTo(p2);
    assertThat(p1).isNotEqualTo(p3);
    assertThat(p1).isNotEqualTo(p4);
    assertThat(p1).isNotEqualTo(p5);
    assertThat(p3).isNotEqualTo(p4);
    assertThat(p3).isNotEqualTo(p5);
    assertThat(p4).isNotEqualTo(p5);
  }

  @Test
  public void testIsAbsoluteWindowsBackslash() {
    assertTrue(new PathFragment(new File("C:\\blah")).isAbsolute());
    assertTrue(new PathFragment(new File("C:\\")).isAbsolute());
    assertTrue(new PathFragment(new File("\\blah")).isAbsolute());
    assertTrue(new PathFragment(new File("\\")).isAbsolute());
  }

  @Test
  public void testIsNormalizedWindows() {
    assertTrue(new PathFragment("C:/").isNormalized());
    assertTrue(new PathFragment("C:/absolute/path").isNormalized());
    assertFalse(new PathFragment("C:/absolute/./path").isNormalized());
    assertFalse(new PathFragment("C:/absolute/../path").isNormalized());
  }

  @Test
  public void testRootNodeReturnsRootStringWindows() {
    PathFragment rootFragment = new PathFragment("C:/");
    assertEquals("C:/", rootFragment.getPathString());
  }

  @Test
  public void testGetRelativeWindows() {
    assertEquals("C:/a/b", new PathFragment("C:/a").getRelative("b").getPathString());
    assertEquals("C:/a/b/c/d", new PathFragment("C:/a/b").getRelative("c/d").getPathString());
    assertEquals("C:/b", new PathFragment("C:/a").getRelative("C:/b").getPathString());
    assertEquals("C:/c/d", new PathFragment("C:/a/b").getRelative("C:/c/d").getPathString());
    assertEquals("C:/b", new PathFragment("a").getRelative("C:/b").getPathString());
    assertEquals("C:/c/d", new PathFragment("a/b").getRelative("C:/c/d").getPathString());
  }

  private void assertGetRelative(String path, String relative, PathFragment expected)
      throws Exception {
    PathFragment actual = new PathFragment(path).getRelative(relative);
    assertThat(actual.getPathString()).isEqualTo(expected.getPathString());
    assertThat(actual).isEqualTo(expected);
    assertThat(actual.getDriveLetter()).isEqualTo(expected.getDriveLetter());
    assertThat(actual.hashCode()).isEqualTo(expected.hashCode());
  }

  private void assertRelativeTo(String path, String relativeTo, String... expectedPathSegments)
      throws Exception {
    PathFragment expected = new PathFragment('\0', false, expectedPathSegments);
    PathFragment actual = new PathFragment(path).relativeTo(relativeTo);
    assertThat(actual.getPathString()).isEqualTo(expected.getPathString());
    assertThat(actual).isEqualTo(expected);
    assertThat(actual.getDriveLetter()).isEqualTo(expected.getDriveLetter());
    assertThat(actual.hashCode()).isEqualTo(expected.hashCode());
  }

  private void assertCantComputeRelativeTo(String path, String relativeTo) throws Exception {
    try {
      new PathFragment(path).relativeTo(relativeTo);
      Assert.fail("expected failure");
    } catch (Exception e) {
      assertThat(e.getMessage()).contains("is not beneath");
    }
  }

  private static PathFragment makePath(char drive, boolean absolute, String... segments) {
    return new PathFragment(drive, absolute, segments);
  }

  @Test
  public void testGetRelativeMixed() throws Exception {
    assertGetRelative("a", "b", makePath('\0', false, "a", "b"));
    assertGetRelative("a", "/b", makePath('\0', true, "b"));
    assertGetRelative("a", "E:b", makePath('\0', false, "a", "b"));
    assertGetRelative("a", "E:/b", makePath('E', true, "b"));

    assertGetRelative("/a", "b", makePath('\0', true, "a", "b"));
    assertGetRelative("/a", "/b", makePath('\0', true, "b"));
    assertGetRelative("/a", "E:b", makePath('\0', true, "a", "b"));
    assertGetRelative("/a", "E:/b", makePath('E', true, "b"));

    assertGetRelative("D:a", "b", makePath('D', false, "a", "b"));
    assertGetRelative("D:a", "/b", makePath('D', true, "b"));
    assertGetRelative("D:a", "E:b", makePath('D', false, "a", "b"));
    assertGetRelative("D:a", "E:/b", makePath('E', true, "b"));

    assertGetRelative("D:/a", "b", makePath('D', true, "a", "b"));
    assertGetRelative("D:/a", "/b", makePath('D', true, "b"));
    assertGetRelative("D:/a", "E:b", makePath('D', true, "a", "b"));
    assertGetRelative("D:/a", "E:/b", makePath('E', true, "b"));
  }

  @Test
  public void testRelativeTo() throws Exception {
    assertRelativeTo("", "");
    assertCantComputeRelativeTo("", "a");

    assertRelativeTo("a", "", "a");
    assertRelativeTo("a", "a");
    assertCantComputeRelativeTo("a", "b");
    assertRelativeTo("a/b", "a", "b");

    assertRelativeTo("C:", "");
    assertRelativeTo("C:", "C:");
    assertCantComputeRelativeTo("C:/", "");
    assertRelativeTo("C:/", "C:/");
  }

  @Test
  public void testGetChildWorks() {
    PathFragment pf = new PathFragment("../some/path");
    assertEquals(new PathFragment("../some/path/hi"), pf.getChild("hi"));
  }

  // Tests after here test the canonicalization
  private void assertRegular(String expected, String actual) {
    PathFragment exp = new PathFragment(expected);
    PathFragment act = new PathFragment(actual);
    assertThat(exp.getPathString()).isEqualTo(expected);
    assertThat(act.getPathString()).isEqualTo(expected);
    assertThat(act).isEqualTo(exp);
    assertThat(act.hashCode()).isEqualTo(exp.hashCode());
  }

  @Test
  public void testEmptyPathToEmptyPathWindows() {
    assertRegular("C:/", "C:/");
  }

  private void assertAllEqual(PathFragment... ps) {
    assertThat(ps.length).isGreaterThan(1);
    for (int i = 1; i < ps.length; i++) {
      String msg = "comparing items 0 and " + i;
      assertWithMessage(msg + " for getPathString")
          .that(ps[i].getPathString())
          .isEqualTo(ps[0].getPathString());
      assertWithMessage(msg + " for equals").that(ps[0]).isEqualTo(ps[i]);
      assertWithMessage(msg + " for hashCode").that(ps[0].hashCode()).isEqualTo(ps[i].hashCode());
    }
  }

  @Test
  public void testEmptyRelativePathToEmptyPathWindows() {
    // Surprising but correct behavior: a PathFragment made of just a drive identifier (and not the
    // absolute path "C:/") is equal not only to the empty fragment, but (therefore) also to other
    // drive identifiers.
    // This makes sense if you consider that these are still empty paths, the drive letter adds no
    // information to the path itself.
    assertAllEqual(
        PathFragment.EMPTY_FRAGMENT,
        new PathFragment("C:"),
        new PathFragment("D:"),
        new PathFragment('\0', false, new String[0]),
        new PathFragment('C', false, new String[0]),
        new PathFragment('D', false, new String[0]));
    assertAllEqual(new PathFragment("/c"), new PathFragment("/c/"));
    assertThat(new PathFragment("C:/")).isNotEqualTo(new PathFragment("/c"));
    assertThat(new PathFragment("C:/foo")).isNotEqualTo(new PathFragment("/c/foo"));

    assertThat(new PathFragment("C:/")).isNotEqualTo(new PathFragment("C:"));
    assertThat(new PathFragment("C:/").getPathString())
        .isNotEqualTo(new PathFragment("C:").getPathString());
  }

  @Test
  public void testWindowsVolumeUppercase() {
    assertRegular("C:/", "c:/");
  }

  @Test
  public void testRedundantSlashesWindows() {
    assertRegular("C:/", "C:///");
    assertRegular("C:/foo/bar", "C:/foo///bar");
    assertRegular("C:/foo/bar", "C:////foo//bar");
  }

  @Test
  public void testSimpleNameToSimpleNameWindows() {
    assertRegular("C:/foo", "C:/foo");
  }

  @Test
  public void testStripsTrailingSlashWindows() {
    assertRegular("C:/foo/bar", "C:/foo/bar/");
  }

  @Test
  public void testGetParentDirectoryWindows() {
    PathFragment fooBarWizAbs = new PathFragment("C:/foo/bar/wiz");
    PathFragment fooBarAbs = new PathFragment("C:/foo/bar");
    PathFragment fooAbs = new PathFragment("C:/foo");
    PathFragment rootAbs = new PathFragment("C:/");
    assertEquals(fooBarAbs, fooBarWizAbs.getParentDirectory());
    assertEquals(fooAbs, fooBarAbs.getParentDirectory());
    assertEquals(rootAbs, fooAbs.getParentDirectory());
    assertNull(rootAbs.getParentDirectory());

    // Note, this is suprising but correct behaviour:
    assertEquals(fooBarAbs,
                 new PathFragment("C:/foo/bar/..").getParentDirectory());
  }

  @Test
  public void testSegmentsCountWindows() {
    assertEquals(1, new PathFragment("C:/foo").segmentCount());
    assertEquals(0, new PathFragment("C:/").segmentCount());
  }

  @Test
  public void testGetSegmentWindows() {
    assertEquals("foo", new PathFragment("C:/foo/bar").getSegment(0));
    assertEquals("bar", new PathFragment("C:/foo/bar").getSegment(1));
    assertEquals("foo", new PathFragment("C:/foo/").getSegment(0));
    assertEquals("foo", new PathFragment("C:/foo").getSegment(0));
  }

  @Test
  public void testBasenameWindows() throws Exception {
    assertEquals("bar", new PathFragment("C:/foo/bar").getBaseName());
    assertEquals("foo", new PathFragment("C:/foo").getBaseName());
    // Never return the drive name as a basename.
    assertThat(new PathFragment("C:/").getBaseName()).isEmpty();
  }

  private static void assertPath(String expected, PathFragment actual) {
    assertEquals(expected, actual.getPathString());
  }

  @Test
  public void testReplaceNameWindows() throws Exception {
    assertPath("C:/foo/baz", new PathFragment("C:/foo/bar").replaceName("baz"));
    assertNull(new PathFragment("C:/").replaceName("baz"));
  }

  @Test
  public void testStartsWithWindows() {
    assertTrue(new PathFragment("C:/foo/bar").startsWith(new PathFragment("C:/foo")));
    assertTrue(new PathFragment("C:/foo/bar").startsWith(new PathFragment("C:/")));
    assertTrue(new PathFragment("C:foo/bar").startsWith(new PathFragment("C:")));
    assertTrue(new PathFragment("C:/").startsWith(new PathFragment("C:/")));
    assertTrue(new PathFragment("C:").startsWith(new PathFragment("C:")));

    // The first path is absolute, the second is not.
    assertFalse(new PathFragment("C:/foo/bar").startsWith(new PathFragment("C:")));
    assertFalse(new PathFragment("C:/").startsWith(new PathFragment("C:")));
  }

  @Test
  public void testEndsWithWindows() {
    assertTrue(new PathFragment("C:/foo/bar").endsWith(new PathFragment("bar")));
    assertTrue(new PathFragment("C:/foo/bar").endsWith(new PathFragment("foo/bar")));
    assertTrue(new PathFragment("C:/foo/bar").endsWith(new PathFragment("C:/foo/bar")));
    assertTrue(new PathFragment("C:/").endsWith(new PathFragment("C:/")));
  }

  @Test
  public void testGetSafePathStringWindows() {
    assertEquals("C:/", new PathFragment("C:/").getSafePathString());
    assertEquals("C:/abc", new PathFragment("C:/abc").getSafePathString());
    assertEquals("C:/abc/def", new PathFragment("C:/abc/def").getSafePathString());
  }

  @Test
  public void testNormalizeWindows() {
    assertEquals(new PathFragment("C:/a/b"), new PathFragment("C:/a/b").normalize());
    assertEquals(new PathFragment("C:/a/b"), new PathFragment("C:/a/./b").normalize());
    assertEquals(new PathFragment("C:/b"), new PathFragment("C:/a/../b").normalize());
    assertEquals(new PathFragment("C:/../b"), new PathFragment("C:/../b").normalize());
  }
}