#
# Copyright (c) 2009-2010 Nokia Corporation and/or its subsidiary(-ies).
# All rights reserved.
# This component and the accompanying materials are made available
# under the terms of the License "Eclipse Public License v1.0"
# which accompanies this distribution, and is available
# at the URL "http://www.eclipse.org/legal/epl-v10.html".
#
# Initial Contributors:
# Nokia Corporation - initial contribution.
#
# Contributors:
#
# Description: 
#

import generic_path
import unittest
import os
import sys
import re

class TestGenericPaths(unittest.TestCase):
	
	def setUp(self):
		self.cwd = os.getcwd().replace("\\", "/")
	
	def isWin32(self):
		return sys.platform.lower().startswith("win")
	
	
	def testClassCommon(self):
		
		p1 = generic_path.Path("a", "b")
		
		p2 = p1.Append("c")
		self.assertEqual(str(p2), "a/b/c")
		
		p3 = p1.Append("c", "d")
		self.assertEqual(str(p3), "a/b/c/d")
		
		p4 = p1.Prepend("z")
		self.assertEqual(str(p4), "z/a/b")
		
		p5 = p1.Prepend("y", "z")
		self.assertEqual(str(p5), "y/z/a/b")
		
		self.assertEqual(str(p5.Dir()), "y/z/a")
		self.assertEqual(p5.File(), "b")
		
		p6 = generic_path.Join("test")
		self.assertEqual(str(p6.Dir()), "")
		self.assertEqual(p6.File(), "test")
	
	
	def testClassWin32(self):
		if not self.isWin32():
			return
		
		local1 = generic_path.Path('some\\folder\\another\\')
		local2 = generic_path.Join(local1, "test", "tmp")
		
		self.assertEqual(str(local2),"some/folder/another/test/tmp")
		
		# Absolute
		
		local1 = generic_path.Path('some\\folder')
		self.failIf(local1.isAbsolute())
		
		abs1 = local1.Absolute()
		self.assertEqual(str(abs1).lower(), (self.cwd + "/some/folder").lower())
		
		local2 = generic_path.Path('C:\\some\\folder')
		self.failUnless(local2.isAbsolute())
		
		abs2 = local2.Absolute()
		self.assertEqual(str(abs2), "C:/some/folder")

		local3 = generic_path.Path('\\somerandomfolder')
		self.failUnless(re.match('^[A-Za-z]:/somerandomfolder$',str(local3)))

		local4 = generic_path.Path('\\my\\folder\\')
		self.failUnless(re.match('^[A-Za-z]:/my/folder$',str(local4)))

		local5 = generic_path.Path('\\')
		self.failUnless(re.match('^[A-Za-z]:$',str(local5)))
		
		local6 = generic_path.Path("C:")
		self.failUnless(local6.isAbsolute())
		self.failUnless(local6.isDir())
		self.failUnless(local6.Exists())
		
		local7 = local6.Absolute()
		self.assertEqual(str(local7), "C:")
		
		local8 = generic_path.Path("C:/")
		self.failUnless(local8.isAbsolute())
		self.failUnless(local8.isDir())
		self.failUnless(local8.Exists())
		
		local9 = local8.Absolute()
		self.assertEqual(str(local9), "C:")
		                              	
		# Drives
		
		driveD = generic_path.Path("D:\\", "folder")
		self.assertEqual(str(driveD), "D:/folder")
		
		driveA = generic_path.Path("a:\\")
		self.assertEqual(str(driveA), "a:")
		self.assertEqual(str(driveA.Dir()), "a:")
		
		driveZ = generic_path.Path("Z:\\test")
		self.assertEqual(str(driveZ), "Z:/test")
		
		joinC = generic_path.Join("C:\\", "something")
		self.assertEqual(str(joinC), "C:/something")
		
		joinM = generic_path.Join("M:", "something")
		self.assertEqual(str(joinM), "M:/something")
		
		# Path
		
		path2 = generic_path.Path("m:/sys/thing/")
		self.assertEqual(str(path2), "m:/sys/thing")
		
		path3 = generic_path.Path("m:\\sys\\thing\\")
		self.assertEqual(str(path3), "m:/sys/thing")
		
		path4 = generic_path.Path("m:\\")
		self.assertEqual(str(path4), "m:")
		
		path5 = generic_path.Path("\\sys\\thing\\")
		self.failUnless(re.match('^[A-Za-z]:/sys/thing$', str(path5)))
		
		path6 = generic_path.Path("m:/")
		self.assertEqual(str(path6), "m:")
		
		# SpaceSafePath
		
		epocroot = os.path.abspath(os.environ.get('EPOCROOT')).replace('\\','/').rstrip('/')
		pathwithspaces = epocroot+"/epoc32/build/Program Files/Some tool installed with spaces/no_spaces/s p c/no_more_spaces"
		path7 = generic_path.Path(pathwithspaces)

		# SpaceSafe paths on Windows are 8.3 format, and these can only be deduced if they actually exist.	
		os.makedirs(pathwithspaces)
		spacesafe = path7.GetSpaceSafePath()
		self.assertTrue(spacesafe.endswith("PROGRA~1/SOMETO~1/NO_SPA~1/SPC~1/NO_MOR~1"))
		
		os.removedirs(pathwithspaces)
		spacesafe = path7.GetSpaceSafePath()		
		self.assertEqual(spacesafe, None)

		
	def testClassLinux(self):
		if self.isWin32():
			return
		
		local1 = generic_path.Path('some/folder/another/')
		local2 = generic_path.Join(local1, "test", "tmp")
		
		self.assertEqual(str(local2),"some/folder/another/test/tmp")
		
		msys1 = generic_path.Path('some/folder/another/')
		msys2 = generic_path.Join(msys1, "test", "tmp")
		
		self.assertEqual(str(msys2),"some/folder/another/test/tmp")
		
		# Absolute
		
		local1 = generic_path.Path('some/folder')
		self.failIf(local1.isAbsolute())
		
		abs1 = local1.Absolute()
		self.assertEqual(str(abs1), self.cwd + "/some/folder")
		
		local2 = generic_path.Path('/some/folder')
		self.failUnless(local2.isAbsolute())
		
		abs2 = local2.Absolute()
		self.assertEqual(str(abs2), "/some/folder")
		
		root = generic_path.Path("/")
		self.assertEqual(str(root), "/")
		
		# Path
		
		path = generic_path.Path("some/thing/")
		self.assertEqual(str(path), "some/thing")
		
		# SpaceSafePath
		
		# This doesn't mean much on non-Windows platforms, but we confirm nothing breaks if it is used
		pathwithspaces = "/Program Files/Some tool installed with spaces/no_spaces/s p c/no_more_spaces"
		path2 = generic_path.Path(pathwithspaces)
	
		spacesafe = path2.GetSpaceSafePath()		
		self.assertEqual(spacesafe, None)
		
 
# run all the tests

from raptor_tests import SmokeTest

def run():
	t = SmokeTest()
	t.id = "999"
	t.name = "generic_path_unit"

	tests = unittest.makeSuite(TestGenericPaths)
	result = unittest.TextTestRunner(verbosity=2).run(tests)

	if result.wasSuccessful():
		t.result = SmokeTest.PASS
	else:
		t.result = SmokeTest.FAIL

	return t