Beispiel #1
0
def test_cp20174():
    cp20174_path = testpath.public_testdir + r"\cp20174"

    try:
        nt.mkdir(cp20174_path)

        cp20174_init = cp20174_path + r"\__init__.py"
        write_to_file(cp20174_init, "import a")

        cp20174_a = cp20174_path + r"\a.py"
        write_to_file(
            cp20174_a, """
from property import x
class C:
    def _get_x(self): return x
    x = property(_get_x)
""")

        cp20174_property = cp20174_path + r"\property.py"
        write_to_file(cp20174_property, "x=1")

        import cp20174
        AreEqual(cp20174.property.x, 1)

    finally:
        for x in nt.listdir(cp20174_path):
            nt.unlink(cp20174_path + "\\" + x)
        nt.rmdir(cp20174_path)
Beispiel #2
0
def test_cp20174():
    cp20174_path = testpath.public_testdir + r"\cp20174"
    
    try:
        nt.mkdir(cp20174_path)
        
        cp20174_init = cp20174_path + r"\__init__.py"
        write_to_file(cp20174_init, "import a")
        
        cp20174_a = cp20174_path + r"\a.py"
        write_to_file(cp20174_a, """
from property import x
class C:
    def _get_x(self): return x
    x = property(_get_x)
""")
        
        cp20174_property = cp20174_path + r"\property.py"
        write_to_file(cp20174_property, "x=1")
        
        import cp20174
        AreEqual(cp20174.property.x, 1)
        
    finally:
        for x in nt.listdir(cp20174_path):
            nt.unlink(cp20174_path + "\\" + x)
        nt.rmdir(cp20174_path)
Beispiel #3
0
class NtTest(IronPythonTestCase):
    def test_computername(self):
        self.assertEqual(
            nt.environ.has_key('COMPUTERNAME')
            or nt.environ.has_key('computername'), True)

    def test_mkdir(self):
        nt.mkdir('dir_create_test')
        self.assertEqual(nt.listdir(nt.getcwd()).count('dir_create_test'), 1)

        nt.rmdir('dir_create_test')
        self.assertEqual(nt.listdir(nt.getcwd()).count('dir_create_test'), 0)

    def test_mkdir_negative(self):
        nt.mkdir("dir_create_test")
        try:
            nt.mkdir("dir_create_test")
            self.assertUnreachabale("Cannot create the same directory twice")
        except WindowsError, e:
            self.assertEqual(e.errno, 17)

        #if it fails once...it should fail again
        self.assertRaises(WindowsError, nt.mkdir, "dir_create_test")
        nt.rmdir('dir_create_test')
        nt.mkdir("dir_create_test")
        self.assertRaises(WindowsError, nt.mkdir, "dir_create_test")
        nt.rmdir('dir_create_test')
Beispiel #4
0
def test_chmod():
    # chmod tests:
    # BUG 828,830
    nt.mkdir('tmp2')
    nt.chmod('tmp2', 256) # NOTE: change to flag when stat is implemented
    AssertError(OSError, lambda:nt.rmdir('tmp2'))
    nt.chmod('tmp2', 128)
    nt.rmdir('tmp2')
Beispiel #5
0
def test_chmod():
    # chmod tests:
    # BUG 828,830
    nt.mkdir('tmp2')
    nt.chmod('tmp2', 256)  # NOTE: change to flag when stat is implemented
    AssertError(OSError, lambda: nt.rmdir('tmp2'))
    nt.chmod('tmp2', 128)
    nt.rmdir('tmp2')
Beispiel #6
0
    def test_getcwdb(self):
        self.assertEqual(nt.getcwdb(),nt.getcwd().encode())

        nt.mkdir('dir_create_test')
        if is_cli:
            self.assertEqual(nt.listdir(nt.getcwdb()).count('dir_create_test'), 1)
        else:
            self.assertEqual(nt.listdir(nt.getcwdb()).count(b'dir_create_test'), 1)
        nt.rmdir('dir_create_test')
Beispiel #7
0
def test_cp24692():
    import errno, nt, stat
    dir_name = "cp24692_testdir"
    try:
        nt.mkdir(dir_name)
        nt.chmod(dir_name, stat.S_IREAD)
        try:
            nt.rmdir(dir_name)
        except WindowsError, e:
            pass
        AreEqual(e.errno, errno.EACCES)
Beispiel #8
0
def test_cp24692():
    import errno, nt, stat
    dir_name = "cp24692_testdir"
    try:
        nt.mkdir(dir_name)
        nt.chmod(dir_name, stat.S_IREAD)
        try:
            nt.rmdir(dir_name)
        except WindowsError, e:
            pass
        AreEqual(e.errno, errno.EACCES)
Beispiel #9
0
    def test_chdir(self):
        currdir = nt.getcwd()
        nt.mkdir('tsd')
        nt.chdir('tsd')
        self.assertEqual(os.path.join(currdir, 'tsd'), nt.getcwd())
        nt.chdir(currdir)
        self.assertEqual(currdir, nt.getcwd())
        nt.rmdir('tsd')

        # the directory is empty or does not exist
        self.assertRaisesNumber(WindowsError, 22, lambda: nt.chdir(''))
        self.assertRaisesNumber(WindowsError, 2, lambda: nt.chdir('tsd'))
Beispiel #10
0
def test_chdir():
    currdir = nt.getcwd()
    nt.mkdir('tsd')
    nt.chdir('tsd')
    AreEqual(currdir+'\\tsd', nt.getcwd())
    nt.chdir(currdir)
    AreEqual(currdir, nt.getcwd())
    nt.rmdir('tsd')
    
    # the directory is empty or does not exist
    AssertErrorWithNumber(WindowsError, 22, lambda:nt.chdir(''))
    AssertErrorWithNumber(WindowsError, 2, lambda:nt.chdir('tsd'))
Beispiel #11
0
 def test_chdir(self):
     currdir = nt.getcwd()
     nt.mkdir('tsd')
     nt.chdir('tsd')
     self.assertEqual(os.path.join(currdir, 'tsd'), nt.getcwd())
     nt.chdir(currdir)
     self.assertEqual(currdir, nt.getcwd())
     nt.rmdir('tsd')
     
     # the directory is empty or does not exist
     self.assertRaisesNumber(WindowsError, 22, lambda:nt.chdir(''))
     self.assertRaisesNumber(WindowsError, 2, lambda:nt.chdir('tsd'))
Beispiel #12
0
def test_chdir():
    currdir = nt.getcwd()
    nt.mkdir('tsd')
    nt.chdir('tsd')
    AreEqual(currdir + '\\tsd', nt.getcwd())
    nt.chdir(currdir)
    AreEqual(currdir, nt.getcwd())
    nt.rmdir('tsd')

    # the directory is empty or does not exist
    AssertErrorWithNumber(WindowsError, 22, lambda: nt.chdir(''))
    AssertErrorWithNumber(WindowsError, 2, lambda: nt.chdir('tsd'))
Beispiel #13
0
    def test_mkdir_negative(self):
        nt.mkdir("dir_create_test")
        try:
            nt.mkdir("dir_create_test")
            self.assertUnreachabale("Cannot create the same directory twice")
        except WindowsError as e:
            self.assertEqual(e.errno, 17)

        #if it fails once...it should fail again
        self.assertRaises(WindowsError, nt.mkdir, "dir_create_test")
        nt.rmdir('dir_create_test')
        nt.mkdir("dir_create_test")
        self.assertRaises(WindowsError, nt.mkdir, "dir_create_test")
        nt.rmdir('dir_create_test')
Beispiel #14
0
def test_mkdir_negative():
    nt.mkdir("dir_create_test")
    try:
        nt.mkdir("dir_create_test")
        AssertUnreachable("Cannot create the same directory twice")
    except WindowsError as e:
        AreEqual(e.errno, 17)

    #if it fails once...it should fail again
    AssertError(WindowsError, nt.mkdir, "dir_create_test")
    nt.rmdir('dir_create_test')
    nt.mkdir("dir_create_test")
    AssertError(WindowsError, nt.mkdir, "dir_create_test")
    nt.rmdir('dir_create_test')
Beispiel #15
0
def test_access():
    f = file('new_file_name', 'w')
    f.close()
    
    AreEqual(nt.access('new_file_name', nt.F_OK), True)
    AreEqual(nt.access('does_not_exist.py', nt.F_OK), False)

    nt.chmod('new_file_name', 0x100) # S_IREAD
    AreEqual(nt.access('new_file_name', nt.W_OK), False)
    nt.chmod('new_file_name', 0x80)  # S_IWRITE
        
    nt.unlink('new_file_name')
    
    nt.mkdir('new_dir_name')
    AreEqual(nt.access('new_dir_name', nt.R_OK), True)
    nt.rmdir('new_dir_name')
    
    AssertError(TypeError, nt.access, None, 1)
Beispiel #16
0
def test_cp12009():
    import nt
    import shutil
    
    dir1 = "temp_test_stdmodules_dir"
    dir2 = dir1 + "2"
    
    nt.mkdir(dir1)
    f = open(dir1 + r"\stuff.txt", "w")
    f.close()
    
    try:
        shutil.copytree(dir1, dir2)
        Assert("stuff.txt" in nt.listdir(dir2))
    finally:
        for t_dir in [dir1, dir2]:
            nt.unlink(t_dir + r"\stuff.txt")
            nt.rmdir(t_dir)
Beispiel #17
0
def test_access():
    f = file('new_file_name', 'w')
    f.close()
    
    AreEqual(nt.access('new_file_name', nt.F_OK), True)
    AreEqual(nt.access('does_not_exist.py', nt.F_OK), False)

    nt.chmod('new_file_name', 0x100) # S_IREAD
    AreEqual(nt.access('new_file_name', nt.W_OK), False)
    nt.chmod('new_file_name', 0x80)  # S_IWRITE
        
    nt.unlink('new_file_name')
    
    nt.mkdir('new_dir_name')
    AreEqual(nt.access('new_dir_name', nt.R_OK), True)
    nt.rmdir('new_dir_name')
    
    AssertError(TypeError, nt.access, None, 1)
def test_cp12009():
    import nt
    import shutil

    dir1 = "temp_test_stdmodules_dir"
    dir2 = dir1 + "2"

    nt.mkdir(dir1)
    f = open(dir1 + r"\stuff.txt", "w")
    f.close()

    try:
        shutil.copytree(dir1, dir2)
        Assert("stuff.txt" in nt.listdir(dir2))
    finally:
        for t_dir in [dir1, dir2]:
            nt.unlink(t_dir + r"\stuff.txt")
            nt.rmdir(t_dir)
Beispiel #19
0
def test_access():
    f = file("new_file_name", "w")
    f.close()

    AreEqual(nt.access("new_file_name", nt.F_OK), True)
    AreEqual(nt.access("does_not_exist.py", nt.F_OK), False)

    nt.chmod("new_file_name", 0x100)  # S_IREAD
    AreEqual(nt.access("new_file_name", nt.W_OK), False)
    nt.chmod("new_file_name", 0x80)  # S_IWRITE

    nt.unlink("new_file_name")

    nt.mkdir("new_dir_name")
    AreEqual(nt.access("new_dir_name", nt.R_OK), True)
    nt.rmdir("new_dir_name")

    AssertError(TypeError, nt.access, None, 1)
Beispiel #20
0
    def test_access(self):
        open('new_file_name', 'w').close()

        self.assertEqual(nt.access('new_file_name', nt.F_OK), True)
        self.assertEqual(nt.access('new_file_name', nt.R_OK), True)
        self.assertEqual(nt.access('does_not_exist.py', nt.F_OK), False)
        self.assertEqual(nt.access('does_not_exist.py', nt.R_OK), False)

        nt.chmod('new_file_name', 0x100) # S_IREAD
        self.assertEqual(nt.access('new_file_name', nt.W_OK), False)
        nt.chmod('new_file_name', 0x80)  # S_IWRITE

        nt.unlink('new_file_name')

        nt.mkdir('new_dir_name')
        self.assertEqual(nt.access('new_dir_name', nt.R_OK), True)
        nt.rmdir('new_dir_name')

        self.assertRaises(TypeError, nt.access, None, 1)
Beispiel #21
0
def test_rename():
    # normal test
    handler = open("oldnamefile.txt", "w")
    handler.close()
    str_old = "oldnamefile.txt"
    dst = "newnamefile.txt"
    nt.rename(str_old, dst)
    AreEqual(nt.listdir(nt.getcwd()).count(dst), 1)
    AreEqual(nt.listdir(nt.getcwd()).count(str_old), 0)
    nt.remove(dst)

    # the destination name is a directory
    handler = open("oldnamefile.txt", "w")
    handler.close()
    str_old = "oldnamefile.txt"
    dst = "newnamefile.txt"
    nt.mkdir(dst)
    AssertError(OSError, nt.rename, str_old, dst)
    nt.rmdir(dst)
    nt.remove(str_old)

    # the dst already exists
    handler1 = open("oldnamefile.txt", "w")
    handler1.close()
    handler2 = open("newnamefile.txt", "w")
    handler2.close()
    str_old = "oldnamefile.txt"
    dst = "newnamefile.txt"
    AssertError(OSError, nt.rename, str_old, dst)
    nt.remove(str_old)
    nt.remove(dst)

    # the source file specified does not exist
    str_old = "oldnamefile.txt"
    dst = "newnamefile.txt"
    AssertError(OSError, nt.rename, str_old, dst)
Beispiel #22
0
def test_rename():
    # normal test
    handler = open("oldnamefile.txt","w")
    handler.close()
    str_old = "oldnamefile.txt"
    dst = "newnamefile.txt"
    nt.rename(str_old,dst)
    AreEqual(nt.listdir(nt.getcwd()).count(dst), 1)
    AreEqual(nt.listdir(nt.getcwd()).count(str_old), 0)
    nt.remove(dst)
    
    # the destination name is a directory
    handler = open("oldnamefile.txt","w")
    handler.close()
    str_old = "oldnamefile.txt"
    dst = "newnamefile.txt"
    nt.mkdir(dst)
    AssertError(OSError, nt.rename,str_old,dst)
    nt.rmdir(dst)
    nt.remove(str_old)
    
    # the dst already exists
    handler1 = open("oldnamefile.txt","w")
    handler1.close()
    handler2 = open("newnamefile.txt","w")
    handler2.close()
    str_old = "oldnamefile.txt"
    dst = "newnamefile.txt"
    AssertError(OSError, nt.rename,str_old,dst)
    nt.remove(str_old)
    nt.remove(dst)
    
    # the source file specified does not exist
    str_old = "oldnamefile.txt"
    dst = "newnamefile.txt"
    AssertError(OSError, nt.rename,str_old,dst)
Beispiel #23
0
 def test_getcwdu(self):
     self.assertEqual(nt.getcwd(),nt.getcwdu())
     
     nt.mkdir('dir_create_test')
     self.assertEqual(nt.listdir(nt.getcwdu()).count('dir_create_test'), 1)
     nt.rmdir('dir_create_test')
Beispiel #24
0

def test_cp24692():
    import errno, nt, stat
    dir_name = "cp24692_testdir"
    try:
        nt.mkdir(dir_name)
        nt.chmod(dir_name, stat.S_IREAD)
        try:
            nt.rmdir(dir_name)
        except WindowsError, e:
            pass
        AreEqual(e.errno, errno.EACCES)
    finally:
        nt.chmod(dir_name, stat.S_IWRITE)
        nt.rmdir(dir_name)


# TODO: this test needs to run against Dev10 builds as well
@skip("win32")
def test_cp22735():
    import System
    if System.Environment.Version.Major < 4:
        clr.AddReference("System.Core")
    from System import Func


#------------------------------------------------------------------------------
#--General coverage.  These need to be extended.
def test_xxsubtype_bench():
    import xxsubtype
Beispiel #25
0
def test_mkdir():
    nt.mkdir("dir_create_test")
    AreEqual(nt.listdir(nt.getcwd()).count("dir_create_test"), 1)

    nt.rmdir("dir_create_test")
    AreEqual(nt.listdir(nt.getcwd()).count("dir_create_test"), 0)
Beispiel #26
0
        f.close()

    for mode in ('wb', 'w'):
        f = open(fsync_file_name, mode)
        nt.fsync(f.fileno())
        f.close()

    nt.unlink(fsync_file_name)

    # fsync on pipe ends
    r, w = nt.pipe()
    AssertError(OSError, nt.fsync, r)
    nt.write(w, '1')
    nt.fsync(w)
    nt.close(w)
    nt.close(r)


#------------------------------------------------------------------------------
try:
    run_test(__name__)
finally:
    #test cleanup - the test functions create the following directories and if any of them
    #fail, the directories may not necessarily be removed.  for this reason we try to remove
    #them again
    for temp_dir in ['dir_create_test', 'tsd', 'tmp2', 'newnamefile.txt']:
        try:
            nt.rmdir(temp_dir)
        except:
            pass
Beispiel #27
0
            f.close()

        for mode in ('wb', 'w'):
            f = open(fsync_file_name, mode)
            nt.fsync(f.fileno())
            f.close()

        nt.unlink(fsync_file_name)

        # fsync on pipe ends
        r,w = nt.pipe()
        self.assertRaises(OSError, nt.fsync, r)
        nt.write(w, '1')
        nt.fsync(w)
        nt.close(w)
        nt.close(r)

#------------------------------------------------------------------------------
try:
    run_test(__name__)
finally:
    #test cleanup - the test functions create the following directories and if any of them
    #fail, the directories may not necessarily be removed.  for this reason we try to remove
    #them again
    for temp_dir in ['dir_create_test', 'tsd', 'tmp2', 'newnamefile.txt']:
        try:
            nt.rmdir(temp_dir)
        except:
            pass

Beispiel #28
0
def test_getcwdu():
    AreEqual(nt.getcwd(),nt.getcwdu())
    
    nt.mkdir('dir_create_test')
    AreEqual(nt.listdir(nt.getcwdu()).count('dir_create_test'), 1)
    nt.rmdir('dir_create_test')
Beispiel #29
0
    nt.rmdir('dir_create_test')
    AreEqual(nt.listdir(nt.getcwd()).count('dir_create_test'), 0)


def test_mkdir_negative():
    nt.mkdir("dir_create_test")
    try:
        nt.mkdir("dir_create_test")
        AssertUnreachable("Cannot create the same directory twice")
    except WindowsError, e:
        AreEqual(e.errno, 17)

    #if it fails once...it should fail again
    AssertError(WindowsError, nt.mkdir, "dir_create_test")
    nt.rmdir('dir_create_test')
    nt.mkdir("dir_create_test")
    AssertError(WindowsError, nt.mkdir, "dir_create_test")
    nt.rmdir('dir_create_test')


def test_listdir():
    AssertError(TypeError, nt.listdir, None)
    AreEqual(nt.listdir(nt.getcwd()), nt.listdir('.'))


# stat,lstat
def test_stat():
    # stat
    AssertError(nt.error, nt.stat, 'doesnotexist.txt')
def test_cp15803():
    '''
    '''
    _testdir = 'cp15803'
    pickle_file = path_combine(testpath.public_testdir, "cp15803.pickle")
    
    module_txt = """
class K%s(object):
    static_member = 1
    def __init__(self):
        self.member = 2
        
%s = K%s()
"""
    
    _testdir_init       = path_combine(testpath.public_testdir, _testdir, '__init__.py')
    write_to_file(_testdir_init, module_txt % ("", "FROM_INIT", ""))
    
    _testdir_mod        = path_combine(testpath.public_testdir, _testdir, 'mod.py')
    write_to_file(_testdir_mod, module_txt % ("Mod", "FROM_MOD", "Mod") + """
from cp15803 import K
FROM_INIT_IN_MOD = K()
"""
    )
    
    _testdir_sub        = path_combine(testpath.public_testdir, _testdir, 'sub')
    _testdir_sub_init   = path_combine(_testdir_sub, '__init__.py')
    write_to_file(_testdir_sub_init)
    
    _testdir_sub_submod = path_combine(_testdir_sub, 'submod.py')
    write_to_file(_testdir_sub_submod, module_txt % ("SubMod", "FROM_SUB_MOD", "SubMod") + """
from cp15803 import mod
FROM_MOD_IN_SUBMOD = mod.KMod()
"""
    )
   
    import cp15803
    import cp15803.mod
    import cp15803.sub.submod
    import cp15803.sub.submod as newname
    
    try:
        for x in [
                    cp15803.K(), cp15803.FROM_INIT,
                    cp15803.mod.KMod(), cp15803.mod.FROM_MOD, cp15803.mod.K(), cp15803.mod.FROM_INIT_IN_MOD,
                    cp15803.sub.submod.KSubMod(), cp15803.sub.submod.FROM_SUB_MOD, cp15803.sub.submod.FROM_MOD_IN_SUBMOD,
                    cp15803.sub.submod.mod.KMod(), cp15803.sub.submod.mod.FROM_MOD, cp15803.sub.submod.mod.K(), cp15803.sub.submod.mod.FROM_INIT_IN_MOD,
                        
                    newname.KSubMod(), newname.FROM_SUB_MOD, newname.FROM_MOD_IN_SUBMOD,
                    newname.mod.KMod(), newname.mod.FROM_MOD, newname.mod.K(), newname.mod.FROM_INIT_IN_MOD,
                    ]:
            with open(pickle_file, "w") as f:
                cPickle.dump(x, f)
            
            with open(pickle_file, "r") as f:
                x_unpickled = cPickle.load(f)
            
                AreEqual(x.__class__.__name__, x_unpickled.__class__.__name__)
                AreEqual(x.static_member, x_unpickled.static_member)
                AreEqual(x.member, x_unpickled.member)
                
    finally:
        import nt
        try:
            nt.unlink(pickle_file)
            for f_name in [ _testdir_init, _testdir_mod,
                            _testdir_sub_init, _testdir_sub_submod,
                            ]:
                nt.unlink(f_name)
                if sys.platform=="win32":
                    nt.unlink(f_name + "c")
            
            
            for dir_name in [ _testdir_sub, _testdir]:
                nt.rmdir(dir_name)
        except:
            pass
Beispiel #31
0
def test_getcwdu():
    AreEqual(nt.getcwd(), nt.getcwdu())

    nt.mkdir('dir_create_test')
    AreEqual(nt.listdir(nt.getcwdu()).count('dir_create_test'), 1)
    nt.rmdir('dir_create_test')
Beispiel #32
0
    def test_getcwdu(self):
        self.assertEqual(nt.getcwd(), nt.getcwdu())

        nt.mkdir('dir_create_test')
        self.assertEqual(nt.listdir(nt.getcwdu()).count('dir_create_test'), 1)
        nt.rmdir('dir_create_test')
Beispiel #33
0
def test_cp15803():
    '''
    '''
    _testdir = 'cp15803'
    pickle_file = path_combine(testpath.public_testdir, "cp15803.pickle")
    
    module_txt = """
class K%s(object):
    static_member = 1
    def __init__(self):
        self.member = 2
        
%s = K%s()
"""
    
    _testdir_init       = path_combine(testpath.public_testdir, _testdir, '__init__.py')
    write_to_file(_testdir_init, module_txt % ("", "FROM_INIT", ""))
    
    _testdir_mod        = path_combine(testpath.public_testdir, _testdir, 'mod.py')
    write_to_file(_testdir_mod, module_txt % ("Mod", "FROM_MOD", "Mod") + """
from cp15803 import K
FROM_INIT_IN_MOD = K()
"""
    )
    
    _testdir_sub        = path_combine(testpath.public_testdir, _testdir, 'sub')
    _testdir_sub_init   = path_combine(_testdir_sub, '__init__.py')
    write_to_file(_testdir_sub_init)
    
    _testdir_sub_submod = path_combine(_testdir_sub, 'submod.py')
    write_to_file(_testdir_sub_submod, module_txt % ("SubMod", "FROM_SUB_MOD", "SubMod") + """
from cp15803 import mod
FROM_MOD_IN_SUBMOD = mod.KMod()
"""
    )
   
    import cp15803
    import cp15803.mod
    import cp15803.sub.submod
    import cp15803.sub.submod as newname
    
    try:
        for x in [
                    cp15803.K(), cp15803.FROM_INIT,
                    cp15803.mod.KMod(), cp15803.mod.FROM_MOD, cp15803.mod.K(), cp15803.mod.FROM_INIT_IN_MOD,
                    cp15803.sub.submod.KSubMod(), cp15803.sub.submod.FROM_SUB_MOD, cp15803.sub.submod.FROM_MOD_IN_SUBMOD,
                    cp15803.sub.submod.mod.KMod(), cp15803.sub.submod.mod.FROM_MOD, cp15803.sub.submod.mod.K(), cp15803.sub.submod.mod.FROM_INIT_IN_MOD,
                        
                    newname.KSubMod(), newname.FROM_SUB_MOD, newname.FROM_MOD_IN_SUBMOD,
                    newname.mod.KMod(), newname.mod.FROM_MOD, newname.mod.K(), newname.mod.FROM_INIT_IN_MOD,
                    ]:
            with open(pickle_file, "w") as f:
                cPickle.dump(x, f)
            
            with open(pickle_file, "r") as f:
                x_unpickled = cPickle.load(f)
            
                AreEqual(x.__class__.__name__, x_unpickled.__class__.__name__)
                AreEqual(x.static_member, x_unpickled.static_member)
                AreEqual(x.member, x_unpickled.member)
                
    finally:
        import nt
        try:
            nt.unlink(pickle_file)
            for f_name in [ _testdir_init, _testdir_mod,
                            _testdir_sub_init, _testdir_sub_submod,
                            ]:
                nt.unlink(f_name)
                if sys.platform=="win32":
                    nt.unlink(f_name + "c")
            
            
            for dir_name in [ _testdir_sub, _testdir]:
                nt.rmdir(dir_name)
        except:
            pass
Beispiel #34
0
    AreEqual(nt.listdir(nt.getcwd()).count('dir_create_test'), 1)
    
    nt.rmdir('dir_create_test')
    AreEqual(nt.listdir(nt.getcwd()).count('dir_create_test'), 0)

def test_mkdir_negative():
    nt.mkdir("dir_create_test")
    try:
        nt.mkdir("dir_create_test")
        AssertUnreachable("Cannot create the same directory twice")
    except WindowsError, e:
        AreEqual(e.errno, 17)
        
    #if it fails once...it should fail again
    AssertError(WindowsError, nt.mkdir, "dir_create_test")
    nt.rmdir('dir_create_test')
    nt.mkdir("dir_create_test")
    AssertError(WindowsError, nt.mkdir, "dir_create_test")
    nt.rmdir('dir_create_test')

def test_listdir():
    AssertError(TypeError, nt.listdir, None)
    if is_cpython: #http://ironpython.codeplex.com/workitem/28207
        AreEqual(nt.listdir(nt.getcwd()), nt.listdir('.'))
    else:
        AreEqual(nt.listdir(''), nt.listdir('.'))

# stat,lstat
def test_stat():
    # stat
    AssertError(nt.error, nt.stat, 'doesnotexist.txt')
Beispiel #35
0
    nt.rmdir("dir_create_test")
    AreEqual(nt.listdir(nt.getcwd()).count("dir_create_test"), 0)


def test_mkdir_negative():
    nt.mkdir("dir_create_test")
    try:
        nt.mkdir("dir_create_test")
        AssertUnreachable("Cannot create the same directory twice")
    except WindowsError, e:
        AreEqual(e.errno, 17)

    # if it fails once...it should fail again
    AssertError(WindowsError, nt.mkdir, "dir_create_test")
    nt.rmdir("dir_create_test")
    nt.mkdir("dir_create_test")
    AssertError(WindowsError, nt.mkdir, "dir_create_test")
    nt.rmdir("dir_create_test")


def test_listdir():
    AssertError(TypeError, nt.listdir, None)
    if is_cpython:  # http://ironpython.codeplex.com/workitem/28207
        AreEqual(nt.listdir(nt.getcwd()), nt.listdir("."))
    else:
        AreEqual(nt.listdir(""), nt.listdir("."))


# stat,lstat
def test_stat():
Beispiel #36
0
             "ENOENT")

def test_cp24692():
    import errno, nt, stat
    dir_name = "cp24692_testdir"
    try:
        nt.mkdir(dir_name)
        nt.chmod(dir_name, stat.S_IREAD)
        try:
            nt.rmdir(dir_name)
        except WindowsError, e:
            pass
        AreEqual(e.errno, errno.EACCES)
    finally:
        nt.chmod(dir_name, stat.S_IWRITE)
        nt.rmdir(dir_name)

# TODO: this test needs to run against Dev10 builds as well
@skip("win32")
def test_cp22735():
    import System
    if System.Environment.Version.Major < 4:
        clr.AddReference("System.Core")
    from System import Func

#------------------------------------------------------------------------------
#--General coverage.  These need to be extended.
def test_xxsubtype_bench():
    import xxsubtype
    AreEqual(type(xxsubtype.bench(xxsubtype, "bench")),
             float)