def runtest(): """check cross-generated output against native reference files""" # object code for infile, opts, reffile in (["gaops.gpl", [], "GAOPS-Q" ], ["gainst.gpl", [], "GAINST-Q"], [ "gabranch.gpl", [], "GABRANCH-Q", ], ["gamove.gpl", [], "GAMOVE-Q" ], ["gafmt.gpl", [], "GAFMT-Q"], ["gadirs.gpl", [], "GADIRS-Q"], ["gacopy.gpl", [], "GACOPY-Q"], ["gaexts.gpl", [], "GAEXTS-Q"], ["gapass.gpl", [], "GAPASS-Q"]): source = os.path.join(Dirs.gplsources, infile) xdm(Disks.gplsrcs, "-e", reffile, "-o", Files.reference) xga(*[source] + opts + ["-w", "-o", Files.output]) check_gbc_files_eq(infile, Files.output, Files.reference) # cart generation for name in ["gacart", "gahello"]: source = os.path.join(Dirs.gplsources, name + ".gpl") ref = os.path.join(Dirs.refs, name + ".rpk") xga(source, "-c", "-o", Files.output) check_files_eq("GPL cart", Files.output, ref, "P", mask=((0x8, 0x1e), (0x188, 0xfff))) # cleanup os.remove(Files.output) os.remove(Files.reference)
def runtest(): """check cross-generated output against native reference files""" # object code for infile, opts, reffile in (['gaops.gpl', [], 'GAOPS-Q'], [ 'gainst.gpl', [], 'GAINST-Q' ], ['gabranch.gpl', [], 'GABRANCH-Q'], ['gamove.gpl', [], 'GAMOVE-Q'], ['gafmt.gpl', [], 'GAFMT-Q'], ['gadirs.gpl', [], 'GADIRS-Q'], ['gacopy.gpl', [], 'GACOPY-Q'], ['gaexts.gpl', [], 'GAEXTS-Q'], ['gapass.gpl', [], 'GAPASS-Q']): source = os.path.join(Dirs.gplsources, infile) xdm(Disks.gplsrcs, '-e', reffile, '-o', Files.reference) xga(*[source] + opts + ['-q', '-o', Files.output]) check_gbc_files_eq(infile, Files.output, Files.reference) # cart generation source = os.path.join(Dirs.gplsources, 'gahello.gpl') ref = os.path.join(Dirs.refs, 'gahello.rpk') xga(source, '-c', '-o', Files.output) with ZipFile(Files.output, 'r') as zout, ZipFile(ref, 'r') as zref: outdata = zout.read('GAHELLO.bin') refdata = zref.read('GAHELLO.bin') if outdata != refdata: error('GPL cart', 'Main file mismatch') if 'layout.xml' not in zout.namelist( ) or 'meta-inf.xml' not in zout.namelist(): error('GPL cart', 'Missing layout or meta-inf files in RPK') # cleanup os.remove(Files.output) os.remove(Files.reference)
def writeImage(disk, data, name): """write raw data as image file to disk""" image = chrw(0) + chrw(imageSize) + chrw(0xA000) + data + (chrw(0x1000) * ( (imageSize - len(data) - 6) / 2)) path = os.path.join(Dirs.sources, name + ".img") with open(path, "wb") as f: f.write(image) xdm(disk, "-a", path, "-n", name)
def write_image(disk, data, name): """write raw data as image file to disk""" image = (bytes(1) + chrw(IMAGE_SIZE) + chrw(0xa000) + data + (chrw(0x1000) * ((IMAGE_SIZE - len(data) - 6) / 2))) path = os.path.join(Dirs.sources, name + '.img') with open(path, 'wb') as f: f.write(image) xdm(disk, '-a', path, '-n', name)
def runtest(): """check cross-generated output against native reference files""" # object code for infile, opts, reffile in [ ("gaops.gpl", [], "GAOPS-Q"), ("gainst.gpl", [], "GAINST-Q"), ("gabranch.gpl", [], "GABRANCH-Q", ), ("gamove.gpl", [], "GAMOVE-Q"), ("gafmt.gpl", ["-s", "rag"], "GAFMT-Q"), ("gadirs.gpl", [], "GADIRS-Q"), ("gacopy.gpl", [], "GACOPY-Q"), ("gaexts.gpl", [], "GAEXTS-Q"), ("gapass.gpl", [], "GAPASS-Q") ]: source = os.path.join(Dirs.gplsources, infile) xdm(Disks.gplsrcs, "-e", reffile, "-o", Files.reference) xga(*[source] + opts + ["-o", Files.output]) checkGbcFilesEq(infile, Files.output, Files.reference) # cart generation for name in ["gacart", "gahello"]: source = os.path.join(Dirs.gplsources, name + ".gpl") ref = os.path.join(Dirs.refs, name + ".rpk") xga(source, "-c", "-o", Files.output) checkFilesEq("GPL cart", Files.output, ref, "P", mask=((0x8, 0x1e), (0x188, 0xfff))) # extensions source = os.path.join(Dirs.gplsources, "gaxprep.gpl") xga(source, "-D", "isdef=2", "-o", Files.output) xdm(Disks.gplsrcs, "-e", "GAXPREP-Q", "-o", Files.reference) checkGbcFilesEq(source, Files.output, Files.reference) # error messages for s in ["gaerrs0.gpl", "gaerrs1.gpl"]: source = os.path.join(Dirs.gplsources, s) with open(source, "r") as fin: expect = [lino + 1 for lino, line in enumerate(fin) if "* ERROR" in line] with open(Files.error, "w") as ferr: xga(source, "-o", Files.output, stderr=ferr, rc=1) with open(Files.error, "r") as fin: try: found = [int(line[:4]) for line in fin if line[0] != "*"] except ValueError: error("Error messages", "Unexpected error message") if found != expect: error("Error messages", "Error mismatch, extra: " + str([x for x in found if x not in expect]) + " missing: " + str([x for x in expect if x not in found])) # cleanup os.remove(Files.output) os.remove(Files.reference) os.remove(Files.error)
def runtest(): """check cross-generated output against native reference files""" for infile, opts, reffile in [("ashello.asm", ["-R"], "ASHELLO-L"), ("asdirs.asm", [], "ASDIRS-L"), ("asorgs.asm", [], "ASORGS-L"), ("asopcs.asm", [], "ASOPCS-L"), ("asexprs.asm", [], "ASEXPRS-L"), ("asbss.asm", [], "ASBSS-L"), ("asregs.asm", ["-R"], "ASREGS-L"), ("assize1.asm", [], "ASSIZE1-L"), ("assize2.asm", [], "ASSIZE2-L"), ("assize3.asm", [], "ASSIZE3-L"), ("assize4.asm", [], "ASSIZE4-L"), ("astisym.asm", [], "ASTISYM-L"), ("asimg1.asm", [], "ASIMG1-L"), ("asimg2.asm", [], "ASIMG2-L"), ("asimg3.asm", [], "ASIMG3-L"), ("ascart.asm", ["-R", "-s"], "ASCART-L")]: source = os.path.join(Dirs.sources, infile) xas(*[source] + opts + ["-L", Files.output, "-o", Files.reference]) xdm(Disks.asmsrcs, "-e", reffile, "-o", Files.reference) check_list_files_eq(Files.output, Files.reference) for infile, opts, reffile in [("ascopy.asm", [], "ASCOPY-L") #("ascopyn.asm", [], "ASCOPYN-L") ]: source = os.path.join(Dirs.sources, infile) xas(*[source] + opts + ["-L", Files.output, "-o", Files.reference]) xdm(Disks.asmsrcs, "-e", reffile, "-o", Files.reference) check_list_files_eq(Files.output, Files.reference, ignore_lino=True) # symbols source = os.path.join(Dirs.sources, "ashello.asm") xas(source, "-R", "-L", Files.output, "-S", "-o", Files.input) reffile = os.path.join(Dirs.refs, "ashello.sym") check_end_equal(Files.output, reffile) # EQUs source = os.path.join(Dirs.sources, "ashello.asm") xas(source, "-R", "-E", Files.output, "-o", Files.input) reffile = os.path.join(Dirs.refs, "ashello.sym") check_sym_equ_equiv(Files.output, reffile) # auto-generated constants source = os.path.join(Dirs.sources, "asautogen.asm") xas(source, "-R", "-o", Files.error, "-S", "-L", Files.input) with open(Files.input, "r") as fin, open(Files.output, "w") as fout: lines = fin.readlines()[-20:] fout.writelines(lines) reffile = os.path.join(Dirs.refs, "asautogen.lst") check_text_files_eq("autogen", Files.output, reffile) # cleanup os.remove(Files.output) os.remove(Files.reference) os.remove(Files.error)
def runtest(): """run regression tests""" # other syntax source = os.path.join(Dirs.gplsources, 'gahello_timt.gpl') xga(source, '-y', 'mizapf', '-o', Files.output) ref = os.path.join(Dirs.gplsources, 'gahello.gpl') xga(ref, '-o', Files.reference) check_binary_files_eq('syntax', Files.output, Files.reference) # preprocessor source = os.path.join(Dirs.gplsources, 'gaxprep.gpl') xga(source, '-D', 'isdef=2', '-o', Files.output) xdm(Disks.gplsrcs, '-e', 'GAXPREP-Q', '-o', Files.reference) check_gbc_files_eq(source, Files.output, Files.reference) # directives source = os.path.join(Dirs.gplsources, 'gaxbcopy.gpl') xga(source, '-I', 'gpl', '-o', Files.output) source = os.path.join(Dirs.gplsources, 'gaxbcopyn.gpl') xga(source, '-o', Files.reference) check_binary_files_eq('bcopy', Files.output, Files.reference) # local labels source = os.path.join(Dirs.gplsources, 'gaxlocal.gpl') xga(source, '-o', Files.output) ref = os.path.join(Dirs.gplsources, 'gaxlocaln.gpl') xga(ref, '-o', Files.reference) check_binary_files_eq('locals', Files.output, Files.reference) # floating-point numbers source = os.path.join(Dirs.gplsources, 'gafloat.gpl') xga(source, '-o', Files.output) ref = os.path.join(Dirs.refs, 'asfloat.ref') check_binary_files_eq('float', Files.output, ref) # GROM n or address for source in (' GROM >6000\n DATA $', ' GROM 3\n DATA $'): with open(Files.input, 'w') as fout: fout.writelines(source) xga(Files.input, '-o', Files.output) with open(Files.output, 'rb') as fin: if fin.read()[:4] != b'\x60\x00': error('GROM', 'Incorrect address after GROM directive') # split GROMs source = os.path.join(Dirs.gplsources, 'gasplit.gpl') xga(source, '-g', '-o', Files.output) check_split_groms(3, 3) # cleanup os.remove(Files.input) os.remove(Files.output) os.remove(Files.reference)
def writesrc(): # create disk if not os.path.isfile(Disks.asmsrcs): shutil.copyfile(Disks.blankDD, Disks.asmsrcs) # create source files for name in [ "ASHELLON", "ASDIRS", "ASBSS", "ASORGS", "ASOPCS", "ASEXPRS", "ASREGS", "ASSIZE1", "ASSIZE2", "ASSIZE3", "ASSIZE4", "ASCOPY", "ASCOPY1", "ASCOPY2", "ASCOPY3", "ASCOPY4", "ASCOPYN-TI", "ASIMG1", "ASIMG2", "ASIMG3", "ASTISYM", "ASCART", "ASXEXT", "ASXEXT0-TI", "ASXEXT1-TI", "ASXEXT2-TI", "ASERRS" ]: source = os.path.join(Dirs.sources, name.lower() + ".asm") xdm(Disks.asmsrcs, "-a", source, "-n", name, "-f", "DIS/VAR80")
def writesrc(): # create disk if not os.path.isfile(Disks.asmsrcs): shutil.copyfile(Disks.blankDD, Disks.asmsrcs) # create source files for name in [ "ASHELLO", "ASDIRS", "ASBSS", "ASORGS", "ASOPCS", "ASEXPRS", "ASREGS", "ASSIZE1", "ASSIZE2", "ASSIZE3", "ASSIZE4", "ASCOPY", "ASCOPY1", "ASCOPY2", "ASCOPY3", "ASCOPY4", "ASCOPYN-TI", "ASIMG1", "ASIMG2", "ASIMG3", "ASTISYM", "ASCART", "ASXEXT", "ASXEXT0-TI", "ASXEXT1-TI", "ASXEXT2-TI", "ASERRS" ]: source = os.path.join(Dirs.sources, name.lower() + ".asm") xdm(Disks.asmsrcs, "-a", source, "-n", name, "-f", "DIS/VAR80")
def runtest(): """run regression tests""" # preprocessor source = os.path.join(Dirs.gplsources, "gaxprep.gpl") xga(source, "-D", "isdef=2", "-o", Files.output) xdm(Disks.gplsrcs, "-e", "GAXPREP-Q", "-o", Files.reference) check_gbc_files_eq(source, Files.output, Files.reference) # directives source = os.path.join(Dirs.gplsources, "gaxbcopy.gpl") xga(source, "-I", "gpl", "-o", Files.output) source = os.path.join(Dirs.gplsources, "gaxbcopyn.gpl") xga(source, "-o", Files.reference) check_binary_files_eq("bcopy", Files.output, Files.reference) # local labels source = os.path.join(Dirs.gplsources, "gaxlocal.gpl") xga(source, "-o", Files.output) ref = os.path.join(Dirs.gplsources, "gaxlocaln.gpl") xga(ref, "-o", Files.reference) check_binary_files_eq("locals", Files.output, Files.reference) # floating-point numbers source = os.path.join(Dirs.gplsources, "gafloat.gpl") xga(source, "-o", Files.output) ref = os.path.join(Dirs.refs, "asfloat.ref") check_binary_files_eq("float", Files.output, ref) # GROM n or address for source in (" GROM >6000\n DATA $", " GROM 3\n DATA $"): with open(Files.input, "w") as fout: fout.writelines(source) xga(Files.input, "-o", Files.output) with open(Files.output, "rb") as fin: if fin.read()[:4] != "\x60\x00": error("GROM", "Incorrect address after GROM directive") # cleanup os.remove(Files.input) os.remove(Files.output) os.remove(Files.reference)
def runtest(): """check cross-generated output against native reference files""" for infile, opts, reffile in [ ("ashello.asm", ["-R"], "ASHELLO-L"), ("asdirs.asm", [], "ASDIRS-L"), ("asorgs.asm", [], "ASORGS-L"), ("asopcs.asm", [], "ASOPCS-L"), ("asexprs.asm", [], "ASEXPRS-L"), ("asbss.asm", [], "ASBSS-L"), ("asregs.asm", ["-R"], "ASREGS-L"), ("assize1.asm", [], "ASSIZE1-L"), ("assize2.asm", [], "ASSIZE2-L"), ("assize3.asm", [], "ASSIZE3-L"), ("assize4.asm", [], "ASSIZE4-L"), ("astisym.asm", [], "ASTISYM-L"), ("asimg1.asm", [], "ASIMG1-L"), ("asimg2.asm", [], "ASIMG2-L"), ("asimg3.asm", [], "ASIMG3-L"), ("ascart.asm", ["-R"], "ASCART-L") ]: source = os.path.join(Dirs.sources, infile) xas(*[source] + opts + ["-L", Files.output, "-o", Files.reference]) xdm(Disks.asmsrcs, "-e", reffile, "-o", Files.reference) checkListFilesEq(Files.output, Files.reference) for infile, opts, reffile in [ ("ascopy.asm", [], "ASCOPY-L") #("ascopyn.asm", [], "ASCOPYN-L") ]: source = os.path.join(Dirs.sources, infile) xas(*[source] + opts + ["-L", Files.output, "-o", Files.reference]) xdm(Disks.asmsrcs, "-e", reffile, "-o", Files.reference) checkListFilesEq(Files.output, Files.reference, ignoreLino=True) # cleanup os.remove(Files.output) os.remove(Files.reference)
def runtest(): """check command line interface""" # setup shutil.copyfile(Disks.recsgen, Disks.work) # disk image operations with open(Files.output, "w") as f1, open(Files.reference, "w") as f2: xdm(Disks.work, "-i", stdout=f2) xdm(Disks.work, "-q", stdout=f1) checkFilesEq("CLI", Files.output, Files.reference, "DIS/VAR255") xdm(Disks.work, "-e", "PROG00255", "DV064X010", "DF002X001") xdm(Disks.work, "-e", "PROG00255", "-o", Files.output) checkFilesEq("CLI", Files.output, "prog00255", "PROGRAM") xdm(Disks.work, "-e", "DV064X010", "-o", Files.output) checkFilesEq("CLI", Files.output, "dv064x010", "DIS/VAR64") xdm(Disks.work, "-e", "DF002X001", "-o", Files.output) checkFilesEq("CLI", Files.output, "df002x001", "DIS/FIX 2") with open(Files.output, "w") as f1: xdm(Disks.work, "-p", "DV064X010", stdout=f1) checkFilesEq("CLI", Files.output, "dv064x010", "DIS/VAR 64") with open(Files.error, "w") as ferr: xdm(Disks.work, "-e", "INVALID", stderr=ferr, rc=1) xdm(Disks.work, "-S", "0x01", "-o", Files.output) checkFilesEq("CLI", Files.output, os.path.join(Dirs.refs, "sector1"), "DIS/VAR255") # add, rename, remove files shutil.copyfile(Disks.blank, Disks.work) xdm(Disks.work, "-a", "prog00255", "dv064x010", "df002x001") xdm(Disks.work, "-e", "PROG00255", "-o", Files.output) checkFilesEq("CLI", Files.output, "prog00255", "PROGRAM") xdm(Disks.work, "-e", "DV064X010", "-o", Files.output) checkFilesEq("CLI", Files.output, "dv064x010", "PROGRAM") #! shutil.copyfile(Disks.work, Disks.tifiles) xdm(Disks.work, "-e", "PROG00255", "-o", Files.reference) xdm(Disks.work, "-r", "PROG00255:OTHERNAME") xdm(Disks.work, "-e", "OTHERNAME", "-o", Files.output) checkFilesEq("CLI", Files.output, Files.reference, "P") xdm(Disks.work, "-r", "OTHERNAME:PROG00255") checkFilesEq("CLI", Disks.work, Disks.tifiles, "P") xdm(Disks.work, "-d", "PROG00255", "DV064X010", "DF002X001") with open(Files.output, "w") as f1, open(Files.reference, "w") as f2: xdm(Disks.work, "-i", stdout=f1) xdm(Disks.blank, "-i", stdout=f2) checkFilesEq("CLI", Files.output, Files.reference, "DIS/VAR255") shutil.copyfile(Disks.recsgen, Disks.work) xdm(Disks.work, "-e", "DF127*", "PROG00001", "PROG00002") if (not os.path.isfile("df127x001") or not os.path.isfile("df127x010") or not os.path.isfile("df127x020p")): error("CLI", "DF127*: Missing files") xdm(Disks.work, "-d", "PROG*", "D?010X060") with open(Files.error, "w") as ferr: xdm(Disks.work, "-e", "PROG00255", stderr=ferr, rc=1) xdm(Disks.work, "-e", "DV010X060", stderr=ferr, rc=1) xdm(Disks.work, "-e", "DF010X060", stderr=ferr, rc=1) # multi-file naming xdm(Disks.work, "-n", "MULTI", "-a", "prog00001", "prog00255", "prog00002") xdm(Disks.work, "-e", "MULTI", "-o", Files.output) checkFilesEq("CLI", "prog00001", Files.output, "P") xdm(Disks.work, "-e", "MULTJ", "-o", Files.output) checkFilesEq("CLI", "prog00255", Files.output, "P") xdm(Disks.work, "-e", "MULTK", "-o", Files.output) checkFilesEq("CLI", "prog00002", Files.output, "P") xdm("-T", "prog00001", "prog00255", "prog00002", "-n", "MULTFI") xdm(Disks.work, "-t", "-a", "prog00001.tfi", "prog00255.tfi", "prog00002.tfi") xdm(Disks.work, "-e", "MULTFI", "-o", Files.output) checkFilesEq("CLI", "prog00001", Files.output, "P") xdm(Disks.work, "-e", "MULTFJ", "-o", Files.output) checkFilesEq("CLI", "prog00255", Files.output, "P") xdm(Disks.work, "-e", "MULTFK", "-o", Files.output) checkFilesEq("CLI", "prog00002", Files.output, "P") xdm("-T", "prog00255", "prog00002", "-9", "-n", "MULV9T") xdm(Disks.work, "-9", "-a", "prog00255.v9t9", "prog00002.v9t9") xdm(Disks.work, "-e", "MULV9T", "-o", Files.output) checkFilesEq("CLI", "prog00255", Files.output, "P") xdm(Disks.work, "-e", "MULV9U", "-o", Files.output) checkFilesEq("CLI", "prog00002", Files.output, "P") ref = os.path.join(Dirs.refs, "glob") xdm(Disks.work, "-a", ref + "?", "-n", "GLOBA1", shell=True) xdm(Disks.work, "-e", "GLOBA1", "-o", Files.output) xdm(Disks.work, "-e", "GLOBA2", "-o", Files.output) with open(Files.error, "w") as ferr: xdm(Disks.work, "-e", "GLOBA3", "-o", Files.output, stderr=ferr, rc=1) xdm(Disks.work, "-d", "GLOB*", "-o", Files.output) xdm(Disks.work, "-a", ref + "*", "-n", "GLOBB1", shell=True) xdm(Disks.work, "-e", "GLOBB1", "-o", Files.output) xdm(Disks.work, "-e", "GLOBB2", "-o", Files.output) xdm(Disks.work, "-e", "GLOBB3", "-o", Files.output) # initialize disk xdm(Disks.work, "--initialize", "360", "-n", "SSSD") checkFileSize(Disks.work, 360 * 256) checkFilesEq("CLI", Disks.work, Disks.blank, "P") os.remove(Disks.work) xdm(Disks.work, "--initialize", "SSSD", "-n", "SSSD") checkFileSize(Disks.work, 360 * 256) checkFilesEq("CLI", Disks.work, Disks.blank, "P") xdm(Disks.work, "--initialize", "800", "-n", "INIT") with open(Files.output, "w") as f: xdm(Disks.work, "-i", stdout=f) checkFileMatches(Files.output, [(0, "\s2\s+used\s+798\s+free\s")]) os.remove(Disks.work) xdm(Disks.work, "--initialize", "CF", "-n", "INIT") with open(Files.output, "w") as f: xdm(Disks.work, "-i", stdout=f) checkFileMatches(Files.output, [(0, "\s2\s+used\s+1598\s+free\s")]) with open(Files.error, "w") as ferr: xdm(Disks.work, "--initialize", "1", stderr=ferr, rc=1) xdm(Disks.work, "--initialize", "1601", stderr=ferr, rc=1) xdm(Disks.work, "--initialize", "FOO", stderr=ferr, rc=1) f = os.path.join(Dirs.refs, "vardis") for n in ["AA", "BB"]: xdm(Disks.work, "--initialize", "SSSD", "-a", f, "-n", n) with open(Files.output, "w") as fout: xdm(Disks.work, "-i", stdout=fout) checkFileMatches(Files.output, [(0, n + "\s+"), (2, n + "\s+")]) # set geometry xdm(Disks.work, "--initialize", "1600", "-n", "GEO") for g, p in [("1S1D", "1S/1D\s+40 TpS"), ("99T8D7S", "7S/8D\s+99 TpS"), ("22TDD", "7S/2D\s+22 TpS"), ("DSSD", "2S/1D\s+22 TpS"), ("1T", "2S/1D\s+1 TpS"), ("3D10T9S", "9S/3D\s+10 TpS"), ("SDDS", "2S/1D\s+10 TpS"), ("SS", "1S/1D\s+10 TpS")]: xdm(Disks.work, "--set-geometry", g) with open(Files.output, "w") as fout: xdm(Disks.work, "-i", "-q", stdout=fout) checkFileMatches(Files.output, [(0, p)]) # resize disk shutil.copyfile(Disks.recsgen, Disks.work) for s in ["800", "248", "1600"]: xdm(Disks.work, "-Z", s, "-q") for f in ["PROG02560", "DF129X010", "DV127X010", "DV255X015P"]: xdm(Disks.work, "-e", f, "-q", "-o", Files.output) xdm(Disks.recsgen, "-e", f, "-o", Files.reference) checkFilesEq("CLI", Files.output, Files.reference, "PROGRAM") with open(Files.error, "w") as ferr: xdm(Disks.work, "-Z", "240", stderr=ferr, rc=1) xdm(Disks.work, "-Z", "1608", stderr=ferr, rc=1) # new geometry handling (v1.5.3) for c, g, p in [ ("--initialize", "SSSD", r"358 free\s+90 KB\s+1S/1D\s+40 TpS"), ("--resize", "DS1D", r"718 free\s+180 KB\s+2S/1D\s+40 TpS"), ("--set-geometry", "80T", r"718 free\s+180 KB\s+2S/1D\s+80 TpS"), # geom mismatch ("--initialize", "408", r"406 free\s+102 KB\s+2S/1D\s+40 TpS"), ("--resize", "DSSD80T", r"1438 free\s+360 KB\s+2S/1D\s+80 TpS"), ("--resize", "2DSS", r"718 free\s+180 KB\s+1S/2D\s+40 TpS"), ("-Z", "208", r"206 free\s+52 KB\s+1S/2D\s+40 TpS"), ("--set-geometry", "SD80T", r"206 free\s+52 KB\s+1S/1D\s+80 TpS"), ("-X", "DSSD80T", r"1438 free\s+360 KB\s+2S/1D\s+80 TpS"), ("--set-geometry", "20T", r"1438 free\s+360 KB\s+2S/1D\s+20 TpS")]: # geom mismatch xdm(Disks.work, c, g) with open(Files.output, "w") as fout: xdm(Disks.work, "-i", "-q", stdout=fout) checkFileMatches(Files.output, [(0, p)]) with open(Files.error, "w") as ferr: xdm(Disks.work, "--initialize", "SS80T", stderr=ferr, rc=1) xdm(Disks.work, "--resize", "2S", stderr=ferr, rc=1) xdm(Disks.work, "--resize", "80T", stderr=ferr, rc=1) xdm(Disks.work, "--set-geometry", "123", stderr=ferr, rc=1) # repair disks shutil.copyfile(Disks.bad, Disks.work) with open(Files.output, "w") as f1, open(Files.reference, "w") as f2: xdm(Disks.work, "-C", stderr=f1, rc=1) xdm(Disks.work, "-R", stderr=f2) checkFileLen(Files.output, minlines=2) with open(Files.output, "w") as f1: xdm(Disks.work, "-C", stderr=f1) checkFileLen(Files.output, maxlines=0) # FIAD operations shutil.copyfile(Disks.recsgen, Disks.work) xdm(Disks.work, "-e", "PROG00255", "DV064X010", "-t") xdm(Disks.work, "-e", "PROG00255", "-t", "-o", Files.output) checkFilesEq("CLI", Files.output, "prog00255.tfi", "PROGRAM") xdm(Disks.work, "-e", "DV064X010", "-t", "-o", Files.output) checkFilesEq("CLI", Files.output, "dv064x010.tfi", "PROGRAM") with open(Files.output, "w") as f: xdm("-I", "prog00255.tfi", "dv064x010.tfi", stdout=f) xdm(Disks.work, "-e", "PROG00255", "DV064X010", "-9") xdm(Disks.work, "-e", "PROG00255", "-9", "-o", Files.output) checkFilesEq("CLI", Files.output, "prog00255.v9t9", "PROGRAM") xdm(Disks.work, "-e", "DV064X010", "-9", "-o", Files.output) checkFilesEq("CLI", Files.output, "dv064x010.v9t9", "PROGRAM") with open(Files.output, "w") as f: xdm("-I", "prog00255.v9t9", "dv064x010.v9t9", stdout=f) xdm(Disks.work, "-e", "PROG00255") xdm("-T", "prog00255", "-o", Files.output) checkFilesEq("CLI", Files.output, "prog00255.tfi", "PROGRAM", Masks.TIFile) xdm("-T", "prog00255", "-9", "-o", Files.output) checkFilesEq("CLI", Files.output, "prog00255.v9t9", "PROGRAM", Masks.v9t9) xdm(Disks.work, "-e", "DV064X010", "-o", Files.reference) xdm("-F", "dv064x010.tfi") checkFilesEq("CLI", "dv064x010", Files.reference, "DIS/VAR 64") xdm("-F", "dv064x010.tfi", "-o", Files.output) checkFilesEq("CLI", Files.output, "dv064x010", "PROGRAM") xdm("-F", "dv064x010.v9t9", "-9") checkFilesEq("CLI", "dv064x010", Files.reference, "DIS/VAR 64") xdm("-F", "dv064x010.v9t9", "-o", Files.output) checkFilesEq("CLI", Files.output, "dv064x010", "PROGRAM") xdm("-T", "dv064x010", "-o", Files.output, "-n", "DV064X010", "-f", "DIS/VAR 64") checkFilesEq("CLI", Files.output, "dv064x010.tfi", "PROGRAM", Masks.TIFile) os.remove("dv064x010.tfi") xdm("-T", "dv064x010", "-n", "DV064X010", "-f", "DIS/VAR 64") checkFilesEq("CLI", "dv064x010.tfi", Files.output, "PROGRAM", Masks.TIFile) xdm("-T", "dv064x010", "-9", "-o", Files.output, "-n", "DV064X010", "-f", "DIS/VAR 64") checkFilesEq("CLI", Files.output, "dv064x010.v9t9", "PROGRAM", Masks.v9t9) os.remove("dv064x010.v9t9") xdm("-T", "dv064x010", "-9", "-n", "DV064X010", "-f", "DIS/VAR 64") checkFilesEq("CLI", "dv064x010.v9t9", Files.output, "PROGRAM", Masks.v9t9) # stdin and stdout ref = os.path.join(Dirs.refs, "vardis") with open(ref, "r") as fin: xdm(Disks.work, "--initialize", "sssd", "-a", "-", "-f", "dv40", stdin=fin) with open(Files.output, "w") as fout: xdm(Disks.work, "-e", "STDIN", "-o", "-", stdout=fout) checkFilesEq("stdin/stdout", Files.output, ref, "DV") ref = os.path.join(Dirs.refs, "sector1") with open(Files.reference, "wb") as fout: xdm(Disks.work, "--initialize", "sssd", "-a", ref, "-n", "T", "-o", "-", stdout=fout) with open(Files.reference, "rb") as fin: xdm("-", "-e", "T", "-o", Files.output, stdin=fin) checkFilesEq("stdin/stdout", Files.output, ref, "P") # usage errors with open(Files.error, "w") as ferr: xdm("-a", Files.output, stderr=ferr, rc=1) xdm("-T", "prog00001", "prog00002", "-o", Files.output, stderr=ferr, rc=1) xdm("-T", "prog00001", "prog00002", "-9", "-o", Files.output, stderr=ferr, rc=1) xdm("-F", "-o", Files.output, stderr=ferr, rc=2) # cleanup os.remove(Files.output) os.remove(Files.reference) os.remove(Files.error) os.remove(Disks.work) os.remove(Disks.tifiles) for fn in [ "prog00001", "prog00002", "prog00255", "dv064x010", "df002x001", "df127x001", "df127x010", "df127x020p", "prog00001.tfi", "prog00002.tfi", "prog00255.tfi", "dv064x010.tfi", "prog00002.v9t9", "prog00255.v9t9", "dv064x010.v9t9" ]: os.remove(fn)
def runtest(): """compare xbas99 generation to TI references""" for fn in [ "KEYWORDS", "STATMNTS", "NUMBERS", "COMMENTS", "LOWRCASE", "GIBBRISH" ]: # compare generated xbas99 listing with TI BASIC reference xdm(Disks.basic1, "-e", fn, "-o", Files.input) xdm(Disks.basic1, "-e", fn + "-L", "-o", Files.reference) xbas(Files.input, "-d", "-o", Files.output) checkListingEq(Files.output, Files.reference) # ditto with MERGE format xdm(Disks.basic1, "-e", fn + "-M", "-o", Files.input) xbas(Files.input, "-d", "--merge", "-o", Files.output) if os.name != "nt": checkListingEq(Files.output, Files.reference) # compare generated xbas99 basic program with TI BASIC reference xdm(Disks.basic1, "-e", fn + "-L", "-o", Files.input) xdm(Disks.basic1, "-e", fn, "-o", Files.reference) xbas(Files.input, "-c", "-j", "3", "-o", Files.output) checkFilesEq("Tokenization", Files.output, Files.reference, "P") # ditto with non-canonically formatted original source rawlist = os.path.join(Dirs.basic, fn.lower() + ".txt") genListing(rawlist, Files.input) xbas(Files.input, "-c", "-o", Files.output) checkFilesEq("Tokenization", Files.output, Files.reference, "P") # check using randomized listings for i in xrange(8): fn = "RAND%02d" % i xdm(Disks.basic2, "-e", fn, "-o", Files.input) xdm(Disks.basic2, "-e", fn + "-L", "-o", Files.reference) # compare generated xbas99 listing with TI BASIC reference xbas(Files.input, "-d", "-o", Files.output) checkListingEq(Files.output, Files.reference) # compare generated xbas99 basic program with TI BASIC reference xbas(Files.reference, "-c", "-j", "3", "-o", Files.output) checkFilesEq("Tokenization", Files.output, Files.input, "P") # check long format path = os.path.join(Dirs.basic, "sample-l.bin") xbas(path, "-d", "-o", Files.output) path = os.path.join(Dirs.basic, "sample-n.bin") xbas(path, "-d", "-o", Files.reference) checkFilesEq("Long Format", Files.output, Files.reference, "P") # check listing protection xdm(Disks.basic1, "-e", "STATMNTS-L", "-o", Files.input) xbas(Files.input, "-c", "-j", "3", "--protect", "-o", Files.output) xbas(Files.input, "-c", "-j", "3", "-o", Files.reference) checkFilesEq("Protection", Files.output, Files.reference, "P", mask=[(0, 2)]) # cleanup os.remove(Files.input) os.remove(Files.output) os.remove(Files.reference)
def runtest(): """check command line interface""" # input and output files source = os.path.join(Dirs.sources, 'ashellon.asm') with open(Files.output, 'wb') as f: xas(source, '-R', '-o', '-', stdout=f) xdm(Disks.asmsrcs, '-e', 'ASHELLO-O', '-q', '-o', Files.reference) check_obj_code_eq(Files.output, Files.reference) xas(source, '-R', '-o', Dirs.tmp) # -o <dir> if not os.path.isfile(os.path.join(Dirs.tmp, 'ashellon.obj')): error('output', '-o <dir> failed') with open(Files.output, 'wb') as f: xas(source, '-R', '-i', '-D', 'VSBW=>210C', 'VMBW=>2110', 'VWTR=>211C', 'KSCAN=>2108', '-o', '-', stdout=f) xdm(Disks.asmsrcs, '-e', 'ASHELLO-I', '-o', Files.reference) check_image_files_eq(Files.output, Files.reference) with open(Files.output, 'w') as f: xas(source, '-R', '-q', '-o', Files.output, '-L', '-', stdout=f) xdm(Disks.asmsrcs, '-e', 'ASHELLO-L', '-o', Files.reference) check_list_files_eq(Files.output, Files.reference) source = os.path.join(Dirs.sources, 'nonexisting') with open(Files.error, 'w') as ferr: xas(source, '-i', '-R', '-o', Files.output, stderr=ferr, rc=1) with open(Files.error, 'r') as ferr: errs = ferr.readlines() if len(errs) != 1 or 'File not found' not in errs[ 0] or 'nonexisting' not in errs[0]: error('File error', 'Incorrect file error message') # include path source = os.path.join(Dirs.sources, 'ascopyi.asm') incls = os.path.join(Dirs.sources, 'test') + ',' + os.path.join( Dirs.sources, 'test', 'test') xas(source, '-i', '-I', incls, '-o', Files.output) with open(Files.output, 'rb') as f: data = f.read() if len(data) != 6 + 20: error('Include paths', 'Incorrect image length') # command-line definitions source = os.path.join(Dirs.sources, 'asdef.asm') xas(source, '-b', '-D', 's1=1', 's3=3', 's2=4', '-o', Files.output) if content(Files.output) != b'\x01\x03': error('-D', 'Content mismatch') xas(source, '-b', '-D', 's1=2,s2=2,s3=3', '-o', Files.output) if content(Files.output) != b'\x02\x03': error('-D', 'Content mismatch') # rebase -a source = os.path.join(Dirs.sources, 'asrebase.asm') xas(source, '-b', '-a', '>2000', '-o', Files.output) ref = os.path.join(Dirs.sources, 'asrebasen.asm') xas(ref, '-b', '-o', Files.reference) check_binary_files_eq('rebase', Files.output, Files.reference) # various parameter combinations source = os.path.join(Dirs.sources, 'asxbank1.asm') remove([Files.reference]) xas(source, '-b', '-q', '-o', Files.output, '-L', Files.reference) check_exists([Files.reference]) # text data output source = os.path.join(Dirs.sources, 'ascart.asm') xas(source, '-b', '-R', '-o', Files.reference) xas(source, '-t', 'a2', '-R', '-o', Files.output) check_bin_text_equal_bytes(Files.output, Files.reference) source = os.path.join(Dirs.sources, 'asmtext.asm') xas(source, '-t', 'a2', '-R', '-o', Files.output) dat = content(Files.output, mode='r') if (not 'aorg >1000' in dat or 'aorg >1010' in dat or 'data' in dat or not 'byte' in dat or '0x' in dat or not '>' in dat): error('dat', 'Invalid .dat file contents') # symbols source = os.path.join(Dirs.sources, 'assyms.asm') xas(source, '-b', '-R', '-o', Files.reference, '-E', Files.output) check_symbols( Files.output, ( ('VDPWA', 'SCAN'), # referencecs (('START', '>0000'), ('S1', '>0001'), ('S2', '>0018')))) # symbols # disable warnings source = os.path.join(Dirs.sources, 'aswarn.asm') with open(Files.error, 'w') as ferr: xas(source, '-b', '-R', '-q', '-o', Files.output, stderr=ferr, rc=0) if content_len(Files.error) > 0: error('warn', 'warnings, even though disabled') # linker source1 = os.path.join(Dirs.sources, 'aslink0a.asm') source2 = os.path.join(Dirs.sources, 'aslink0b.asm') xas(source1, '-q', '-o', Files.input) xas(source2, '-q', '-o', Files.output) with open(Files.error, "w") as ferr: xas('-l', Files.input, '-ll', Files.output, '-o', Files.reference, rc=2, stderr=ferr) # mutually exclusive # cleanup os.remove(Files.output) os.remove(Files.reference) os.remove(Files.error)
def runtest(): """check command line interface""" # setup with open(Disks.volumes, "wb") as v: for i in xrange(4 * 1600): v.write("\x00" * 256) # Disk.bytesPerSector shutil.copyfile(Disks.recsgen, Disks.work) # volume operations xvm(Disks.volumes, "2", "-w", Disks.recsgen, "--keep-size") xvm(Disks.volumes, "1,3-4", "-w", Disks.recsdis, "--keep-size") with open(Files.error, "w") as fout: xvm(Disks.volumes, "1-5", stdout=fout) xvm(Disks.volumes, "4", "-i", stdout=fout) xvm(Disks.volumes, "5", "-i", stderr=fout, rc=1) xvm(Disks.volumes, "2", "-r", Files.output) checkFilesEq("xvm", Files.output, Disks.recsgen, "P") xvm(Disks.volumes, "1", "-r", Files.output) checkFilesEq("xvm", Files.output, Disks.recsdis, "P") xvm(Disks.volumes, "4", "-r", Files.output) checkFilesEq("xvm", Files.output, Disks.recsdis, "P") xvm(Disks.volumes, "4", "-r", Files.output, "--keep-size") checkFilesEq("xvm", Files.output, Disks.recsdis, "P", mask=[(360 * 256, 1600 * 256)]) # file operations xvm(Disks.volumes, "2", "-e", "DF254X015P", "-o", Files.output) xdm(Disks.recsgen, "-e", "DF254X015P", "-o", Files.reference) checkFilesEq("xvm", Files.output, Files.reference, "P") xvm(Disks.volumes, "1", "-w", Disks.work, "--keep-size") ref = os.path.join(Dirs.refs, "sector1") xdm(Disks.work, "-a", ref, "-f", "DF80") xvm(Disks.volumes, "1", "-a", ref, "-f", "DF80") xvm(Disks.volumes, "1", "-r", Files.output) checkFilesEq("xvm", Files.output, Disks.work, "P") xvm(Disks.volumes, "3", "-w", Disks.work) xvm(Disks.volumes, "3", "-a", ref, "-f", "DF80", "-n", "REFFILE") xvm(Disks.volumes, "3", "-r", Files.output) xdm(Files.output, "-e", "REFFILE", "-q", "-o", Files.reference) ref = os.path.join(Dirs.refs, "glob") xvm(Disks.volumes, "1", "-a", ref + "?", "-n", "GLOBA1", shell=True) xvm(Disks.volumes, "1", "-e", "GLOBA1", "-o", Files.output) xvm(Disks.volumes, "1", "-e", "GLOBA2", "-o", Files.output) with open(Files.error, "w") as ferr: xvm(Disks.volumes, "1", "-e", "GLOBA3", "-o", Files.output, stderr=ferr, rc=1) xvm(Disks.volumes, "1", "-d", "GLOB*", "-o", Files.output) xvm(Disks.volumes, "1", "-a", ref + "*", "-n", "GLOBB1", shell=True) xvm(Disks.volumes, "1", "-e", "GLOBB1", "-o", Files.output) xvm(Disks.volumes, "1", "-e", "GLOBB2", "-o", Files.output) xvm(Disks.volumes, "1", "-e", "GLOBB3", "-o", Files.output) # cleanup os.remove(Files.output) os.remove(Files.reference) os.remove(Files.error) os.remove(Disks.work) os.remove(Disks.volumes)
def runtest(): """check cross-generated output against native reference files""" # object code for infile, opts, reffile, cprfile in [ ("asdirs.asm", [], "ASDIRS-O", "ASDIRS-C"), ("asorgs.asm", [], "ASORGS-O", "ASORGS-C"), ("asopcs.asm", [], "ASOPCS-O", "ASOPCS-C"), ("asexprs.asm", [], "ASEXPRS-O", "ASEXPRS-C"), ("asbss.asm", [], "ASBSS-O", "ASBSS-C"), ("asregs.asm", ["-R"], "ASREGS-O", "ASREGS-C"), ("ashello.asm", ["-R"], "ASHELLO-O", "ASHELLO-C"), ("ascopy.asm", [], "ASCOPY-O", None), ("ascopyn.asm", [], "ASCOPYN-O", None), ("assize1.asm", [], "ASSIZE1-O", "ASSIZE1-C"), ("assize2.asm", [], "ASSIZE2-O", None), ("assize3.asm", [], "ASSIZE3-O", None), ("assize4.asm", [], "ASSIZE4-O", None), ("astisym.asm", [], "ASTISYM-O", "ASTISYM-C"), ("asimg1.asm", [], "ASIMG1-O", "ASIMG1-C"), ("asimg2.asm", [], "ASIMG2-O", None), ("asimg3.asm", [], "ASIMG3-OX", None), #("asreloc.asm", [], "ASRELOC-O", None), ("asxorg.asm", [], "ASXORG-O", None), ("ascart.asm", ["-R"], "ASCART-O", "ASCART-C") ]: source = os.path.join(Dirs.sources, infile) xdm(Disks.asmsrcs, "-e", reffile, "-o", Files.reference) xas(*[source] + opts + ["-o", Files.output]) checkObjCodeEq(Files.output, Files.reference) xas(*[source] + opts + ["--strict", "-o", Files.output]) checkObjCodeEq(Files.output, Files.reference) if cprfile: # compressed object code xas(*[source] + opts + ["-C", "-o", Files.output]) xdm(Disks.asmsrcs, "-e", cprfile, "-o", Files.reference) checkObjCodeEq(Files.output, Files.reference) # image files for infile, opts, reffile in [("ashello.asm", ["-R"], "ASHELLO-I"), ("astisym.asm", [], "ASTISYM-I"), ("asimg1.asm", [], "ASIMG1-I"), ("asimg2.asm", [], "ASIMG2-I") #("asimg3.asm", [], "ASIMG3-I") ]: source = os.path.join(Dirs.sources, infile) xas(*[source] + opts + ["-i", "-o", Files.output]) xdm(Disks.asmsrcs, "-e", reffile, "-o", Files.reference) checkImageFilesEq(Files.output, Files.reference) for infile, reffiles in [ ("aslimg.asm", ["ASLIMG-I", "ASLIMG-J", "ASLIMG-K"]), ("assimg.asm", ["ASSIMG-I", "ASSIMG-J", "ASSIMG-K", "ASSIMG-L"]), ("asreloc.asm", ["ASRELOC-I"]) ]: source = os.path.join(Dirs.sources, infile) xas(source, "-R", "-i", "-o", Files.output) for i, reffile in enumerate(reffiles): xdm(Disks.asmimgs, "-e", reffile, "-o", Files.reference) checkFilesEq("Image file", Files.outputff[i], Files.reference, fmt="P") # cleanup for i in xrange(4): os.remove(Files.outputff[i]) os.remove(Files.reference)
def runtest(): """check command line interface""" # input and output files source = os.path.join(Dirs.sources, "ashello.asm") with open(Files.output, "wb") as f: xas(source, "-R", "-o", "-", stdout=f) xdm(Disks.asmsrcs, "-e", "ASHELLO-O", "-o", Files.reference) checkObjCodeEq(Files.output, Files.reference) with open(Files.output, "wb") as f: xas(source, "-R", "-i", "-o", "-", stdout=f) xdm(Disks.asmsrcs, "-e", "ASHELLO-I", "-o", Files.reference) checkImageFilesEq(Files.output, Files.reference) with open(Files.output, "w") as f: xas(source, "-R", "-o", Files.output, "-L", "-", stdout=f) xdm(Disks.asmsrcs, "-e", "ASHELLO-L", "-o", Files.reference) checkListFilesEq(Files.output, Files.reference) source = os.path.join(Dirs.sources, "nonexisting") with open(Files.error, "w") as ferr: xas(source, "-i", "-R", "-o", Files.output, stderr=ferr, rc=1) with open(Files.error, "r") as ferr: errs = ferr.readlines() if len(errs) != 1 or errs[0][:10] != "File error": error("File errors", "Incorrect file error message") # include path source = os.path.join(Dirs.sources, "ascopyi.asm") incls = os.path.join(Dirs.sources, "test") + "," + \ os.path.join(Dirs.sources, "test", "test") xas(source, "-i", "-I", incls, "-o", Files.output) with open(Files.output, "rb") as f: data = f.read() if len(data[6:]) != 20: error("Include paths", "Incorrect image length") # jumpstart disk source = os.path.join(Dirs.sources, "ashello.asm") xas(source, "-R", "--jumpstart", "-o", Files.output) xdm(Disks.asmsrcs, "-e", "ASHELLO-I", "-o", Files.reference) with open(Files.output, "rb") as fout, open(Files.reference, "rb") as fref: disk = fout.read() prog = fref.read() if len(disk) != 360 * 256: error("Jumpstart", "Incorrect disk size: %d" % len(disk)) if disk[0:10] != "xas99-JS\xc2\xb9" or disk[56:256] != "\xff" * 200: error("Jumpstart", "Invalid sector 0 data") plen = ordw(prog[2:4]) - 6 if disk[512:512 + plen] != prog[6:6 + plen]: error("Jumpstart", "Invalid program data") # various parameter combinations source = os.path.join(Dirs.sources, "asxbank1.asm") remove([Files.reference]) xas(source, "-b", "-o", Files.output, "-L", Files.reference) checkExists([Files.reference]) # cleanup os.remove(Files.output) os.remove(Files.reference) os.remove(Files.error)
def runtest(): """check reading and writing of random data""" # setup shutil.copyfile(Disks.blank, Disks.work) shutil.copyfile(Disks.blank, Disks.tifiles) # create files files = [] for count, length in [ (1, 2), (300, 2), (60, 10), (10, 63), (10, 64), (10, 126), (1, 127), (10, 127), (10, 128), (10, 129), (1, 254), (5, 254), (1, 255), (5, 255) ]: files.append(createTextFile(count, length, False, False)) files.append(createTextFile(count, length, True, False)) for count, length in [(20, 127), (15, 254), (15, 255)]: files.append(createTextFile(count, length, False, True)) files.append(createTextFile(count, length, True, True)) for size in [1, 2, 254, 255, 511, 513, 2560]: files.append(createBinaryFile(size)) bigFiles = [] for count, length in [(200, 127), (100, 254), (100, 255)]: bigFiles.append(createTextFile(count, length, False, True)) bigFiles.append(createTextFile(count, length, True, True)) for size in [25600]: bigFiles.append(createBinaryFile(size)) # add files one by one and check for name, path, fmt in files: xdm(Disks.work, "-a", path, "-f", fmt) xdm(Disks.work, "-e", name, "-o", Files.output) checkFilesEq("Write records", Files.output, path, fmt) # remove files one by one and check for name, path, fmt in files: xdm(Disks.work, "-e", name, "-o", Files.output) checkFilesEq("Write records", Files.output, path, fmt) xdm(Disks.work, "-d", name) # add all files for name, path, fmt in files: xdm(Disks.work, "-a", path, "-f", fmt) # extract in and convert to/from TIFiles format for name, path, fmt in files: xdm(Disks.work, "-e", name, "-o", Files.reference) xdm(Disks.work, "-e", name, "-t", "-o", Files.tifile) xdm("-F", Files.tifile, "-o", Files.output) checkFilesEq("Write records", Files.output, Files.reference, fmt) xdm("-T", Files.reference, "-o", Files.output, "-f", fmt, "-n", name) checkFilesEq("Write records", Files.output, Files.tifile, "PROGRAM", [(0x1e, 0x26)]) # add and remove TIFiles files for name, path, fmt in files: xdm(Disks.work, "-e", name, "-t", "-o", Files.tifile) xdm(Disks.tifiles, "-t", "-a", Files.tifile) checkFilesEq("Write records", Disks.tifiles, Disks.work, "P") # convert to and from TIFiles cycle for name, fmt in [("intvar32v", "IV32"), ("intfix32v", "IF32"), ("vardis", "dv40")]: path = os.path.join(Dirs.refs, name) xdm(Disks.work, "-a", path, "-f", fmt, "-n", "T") xdm(Disks.work, "-e", "T", "-t", "-o", Files.output) xdm(Disks.work, "-d", "T") xdm(Disks.work, "-a", Files.output, "-t") xdm(Disks.work, "-e", "T", "-o", Files.output) checkFilesEq("TIFiles cycle", Files.output, path, fmt) # add and remove big files for name, path, fmt in bigFiles: xdm(Disks.work, "-a", path, "-f", fmt) xdm(Disks.work, "-e", name, "-o", Files.output) checkFilesEq("Write records", Files.output, path, fmt) xdm(Disks.work, "-d", name) # check truncating of DIS/VAR files with long records path = os.path.join(Dirs.refs, "vardis") with open(path, "r") as f: reflines = f.readlines() for l in [8, 7, 4]: xdm(Disks.work, "-a", path, "-f", "DV%d" % l, "-q") xdm(Disks.work, "-e", "VARDIS", "-o", Files.output) checkTrunc(Files.output, reflines, l) # create well-defined TI disk (checked-in state frozen) shutil.copyfile(Disks.recsgen, Disks.work) for name, path, fmt in files: xdm(Disks.work, "-a", path, "-f", fmt) # remove temporary files for name, path, fmt in files + bigFiles: os.remove(path) os.remove(Files.output) os.remove(Files.tifile) os.remove(Files.reference) os.remove(Disks.work) os.remove(Disks.tifiles)
def runtest(): """check error messages against native assembler listing""" # cross-assembler error messages source = os.path.join(Dirs.sources, "aserrs.asm") with open(Files.error, "w") as ferr: xas(source, "-s", "-o", Files.output, stderr=ferr, rc=1) xaserrors = readstderr(Files.error) # TI assembler error messages tierrors = {} xdm(Disks.asmsrcs, "-e", "ASERRS-L", "-o", Files.reference) with open(Files.reference, "r") as f: for line in f: err = re.match(r"\*{5}\s+([A-Z ]*) - (\d+)", line) if err: lino, errmsg = err.group(2), err.group(1) tierrors[lino] = errmsg # compare compare(tierrors, xaserrors) # xdt99-specific errors source = os.path.join(Dirs.sources, "asxerrs.asm") with open(Files.error, "w") as ferr: xas(source, "-R", "-o", Files.output, stderr=ferr, rc=1) xaserrors = readstderr(Files.error) referrors = {} with open(source, "r") as f: for i, line in enumerate(f): m = re.search(r";ERROR(:....)?", line) if m: if m.group(1): referrors[m.group(1)[1:]] = line else: referrors["%04d" % (i + 1)] = line compare(referrors, xaserrors) # xdt99-specific errors (image generation) source = os.path.join(Dirs.sources, "asxerrsb.asm") with open(Files.error, "w") as ferr: xas(source, "-R", "-b", "-o", Files.output, stderr=ferr, rc=1) xaserrors = readstderr(Files.error) referrors = {} with open(source, "r") as f: for i, line in enumerate(f): m = re.search(r";ERROR(:....)?", line) if m: if m.group(1): referrors[m.group(1)[1:]] = line else: referrors["%04d" % (i + 1)] = line compare(referrors, xaserrors) # files not found source = os.path.join(Dirs.sources, "ascopyi.asm") with open(Files.error, "w") as ferr: xas(source, "-o", Files.output, stderr=ferr, rc=1) # cleanup os.remove(Files.error) os.remove(Files.reference)
def runtest(): """check command line interface""" # setup with open(Disks.volumes, 'wb') as v: for i in range(4 * 1600): v.write(bytes(2 * 256)) # Disk.bytes_per_sector plus padding shutil.copyfile(Disks.recsgen, Disks.work) # volume operations xvm(Disks.volumes, '2', '-w', Disks.recsgen, '--keep-size') xvm(Disks.volumes, '1,3-4', '-w', Disks.recsdis, '--keep-size') with open(Files.error, 'w') as fout: xvm(Disks.volumes, '1-5', stdout=fout) xvm(Disks.volumes, '4', stdout=fout) xvm(Disks.volumes, '5', '-i', stderr=fout, rc=1) xvm(Disks.volumes, '2', '-r', Files.output) check_files_eq('xvm', Files.output, Disks.recsgen, 'P') xvm(Disks.volumes, '1', '-r', Files.output) check_files_eq('xvm', Files.output, Disks.recsdis, 'P') xvm(Disks.volumes, '4', '-r', Files.output) check_files_eq('xvm', Files.output, Disks.recsdis, 'P') xvm(Disks.volumes, '4', '-r', Files.output, '--keep-size') check_files_eq('xvm', Files.output, Disks.recsdis, 'P', mask=[(360 * 256, 1600 * 256)]) # file operations xvm(Disks.volumes, '2', '-e', 'DF254X015P', '-o', Files.output) xdm(Disks.recsgen, '-e', 'DF254X015P', '-o', Files.reference) check_files_eq('xvm', Files.output, Files.reference, 'P') xvm(Disks.volumes, '1', '-w', Disks.work, '--keep-size') ref = os.path.join(Dirs.refs, 'sector1') xdm(Disks.work, '-a', ref, '-f', 'DF80') xvm(Disks.volumes, '1', '-a', ref, '-f', 'DF80') xvm(Disks.volumes, '1', '-r', Files.output) check_files_eq('xvm', Files.output, Disks.work, 'P') xvm(Disks.volumes, '3', '-w', Disks.work) xvm(Disks.volumes, '3', '-a', ref, '-f', 'DF80', '-n', 'REFFILE') xvm(Disks.volumes, '3', '-r', Files.output) xdm(Files.output, '-e', 'REFFILE', '-q', '-o', Files.reference) ref = os.path.join(Dirs.refs, 'glob') xvm(Disks.volumes, '1', '-a', ref + '?', '-n', 'GLOBA1', shell=True) xvm(Disks.volumes, '1', '-e', 'GLOBA1', '-o', Files.output) xvm(Disks.volumes, '1', '-e', 'GLOBA2', '-o', Files.output) with open(Files.error, 'w') as ferr: xvm(Disks.volumes, '1', '-e', 'GLOBA3', '-o', Files.output, stderr=ferr, rc=1) xvm(Disks.volumes, '1', '-d', 'GLOB*', '-o', Files.output) xvm(Disks.volumes, '1', '-a', ref + '*', '-n', 'GLOBB1', shell=True) xvm(Disks.volumes, '1', '-e', 'GLOBB1', '-o', Files.output) xvm(Disks.volumes, '1', '-e', 'GLOBB2', '-o', Files.output) xvm(Disks.volumes, '1', '-e', 'GLOBB3', '-o', Files.output)
def runtest(): """compare extracted files to reference files""" # compare with reference files generated by TI Image Tool shutil.copyfile(Disks.recsdis, Disks.work) for fn in [ 'V1', 'V16', 'V126', 'V127', 'V128', 'V254', 'V10R', 'V64V', 'V255V1', 'V255V2', 'V255V3', 'V255V4', 'V255V5', # NOTE: F1.tfi has incorrect record count 'F16', 'F127', 'F128', 'F129', 'F254', 'F255', 'F64V', 'F10R' ]: xdm(Disks.work, '-e', fn, '-t', '-o', Files.output) check_files_eq('TIFiles', Files.output, os.path.join(Dirs.refs, fn + '.tfi'), 'PROGRAM', Masks.TIFile) # compare with reference files generated by Classic99 for fn in ['V16', 'V127', 'V64V', 'V10R', 'F129', 'F64V', 'F10R']: xdm(Disks.work, '-e', fn, '-9', '-o', Files.output) check_files_eq('v9t9', Files.output, os.path.join(Dirs.refs, fn + '.v9t9'), 'PROGRAM', Masks.v9t9) xdm('-F', Files.output, '-9', '-o', Files.output) xdm(Disks.work, '-e', fn, '-o', Files.reference) check_files_eq('v9t9', Files.output, Files.reference, 'DV') # compare files extracted from fragmented image shutil.copyfile(Disks.frag, Disks.work) for fn in ['F1', 'F6']: xdm(Disks.work, '-e', fn, '-o', Files.output) check_files_eq('Frag Disk', Files.output, os.path.join(Dirs.refs, 'FRAG' + fn), 'DIS/VAR127') xdm(Disks.work, '-d', 'F1') xdm(Disks.work, '-e', 'F6', '-o', Files.output) check_files_eq('Frag Disk', Files.output, os.path.join(Dirs.refs, 'FRAGF6'), 'DIS/VAR127') shutil.copyfile(Disks.frag, Disks.work) xdm(Disks.work, '-a', Files.output, '-n', 'COPY', '-f', 'DIS/VAR127') xdm(Disks.work, '-e', 'F1', '-o', Files.output) check_files_eq('Frag Disk', Files.output, os.path.join(Dirs.refs, 'FRAGF1'), 'DIS/VAR127') # compare short and long TIFiles rfile = os.path.join(Dirs.refs, 'V64V') shutil.copyfile(rfile, Files.reference) with open(Files.output, 'w') as f: xdm('-I', Files.reference, stdout=f) check_file_matches(Files.output, [(0, r'{:10s}'.format(tiname(Files.reference)) + r'\s+4 DIS/VAR 64\s+575 B\s+9 recs\s+[\d:\- ]+M')]) xdm(Disks.work, '-X', 'sssd', '-t', '-a', rfile) xdm(Disks.work, '-e', 'V64V', '-o', Files.output) xdm('-F', rfile, '-o', Files.reference) check_files_eq('Short TIFiles', Files.output, Files.reference, 'DIS/VAR64') # cleanup os.remove(Files.output) os.remove(Disks.work)
def runtest(): """check cross-generated output against native reference files""" # check if listings match E/A for infile, opts, reffile in [('ashellon.asm', ['-R'], 'ASHELLO-L'), ('asdirs.asm', [], 'ASDIRS-L'), ('asorgs.asm', [], 'ASORGS-L'), ('asopcs.asm', [], 'ASOPCS-L'), ('asexprs.asm', [], 'ASEXPRS-L'), ('asbss.asm', [], 'ASBSS-L'), ('asregs.asm', ['-R'], 'ASREGS-L'), ('assize1.asm', [], 'ASSIZE1-L'), ('assize2.asm', [], 'ASSIZE2-L'), ('assize3.asm', [], 'ASSIZE3-L'), ('assize4.asm', [], 'ASSIZE4-L'), ('asextsym.asm', [], 'ASEXTSYM-L'), ('asimg1.asm', [], 'ASIMG1-L'), ('asimg2.asm', [], 'ASIMG2-L'), ('asimg3.asm', [], 'ASIMG3-L'), ('ascart.asm', ['-R', '-s'], 'ASCART-L')]: source = os.path.join(Dirs.sources, infile) xas(*[source] + opts + ['-q', '-L', Files.output, '-o', Files.input]) xdm(Disks.asmsrcs, '-e', reffile, '-o', Files.reference) check_list_files_eq(Files.output, Files.reference) # check if listing words match actual words for infile, opts in [ ('asdirs.asm', []), # cannot use programs with many ?ORGs ('asopcs.asm', []), ('asbss.asm', []), ('asregs.asm', ['-R']), ('ascart.asm', ['-R', '-s']), ('aslist.asm', []) ]: source = os.path.join(Dirs.sources, infile) xas(*[source] + opts + ['-b', '-q', '-L', Files.output, '-o', Files.reference]) check_list_against_binary(Files.output, Files.reference) # changing sources for infile, opts, reffile in [ ('ascopy.asm', [], 'ASCOPY-L') #('ascopyn.asm', [], 'ASCOPYN-L') # TI version is not souce-equal to xas99 version ]: source = os.path.join(Dirs.sources, infile) xas(*[source] + opts + ['-q', '-L', Files.output, '-o', Files.reference]) xdm(Disks.asmsrcs, '-e', reffile, '-o', Files.reference) check_list_files_eq(Files.output, Files.reference, ignore_lino=True) # bytes and padding source = os.path.join(Dirs.sources, 'aslist.asm') xas(source, '-o', Files.input, '-L', Files.output) ref = os.path.join(Dirs.refs, 'aslist.lst') check_text_files_eq('listbytes', Files.output, ref) # symbols source = os.path.join(Dirs.sources, 'ashello.asm') xas(source, '-R', '-L', Files.output, '-S', '-q', '-o', Files.input) reffile = os.path.join(Dirs.refs, 'ashello.sym') check_end_equal(Files.output, reffile) # EQUs source = os.path.join(Dirs.sources, 'ashello.asm') xas(source, '-R', '-E', Files.output, '-q', '-o', Files.input) reffile = os.path.join(Dirs.refs, 'ashello.sym') check_sym_equ_equiv(Files.output, reffile) # auto-generated constants source = os.path.join(Dirs.sources, 'asauto.asm') reffile = os.path.join(Dirs.refs, 'asauto.lst') with open(reffile, 'r') as fref: reflines = [line.rstrip() for line in fref.readlines()] xas(source, '-R', '-o', Files.error, '-S', '-L', Files.output) with open(Files.output, 'r') as fout: lines = [line.rstrip() for line in fout.readlines()][-len(reflines):] if lines != reflines: error('auto', 'auto-const listing mismatch') # cleanup os.remove(Files.output) os.remove(Files.reference) os.remove(Files.error)
def runtest(): """check command line interface""" # setup shutil.copyfile(Disks.recsgen, Disks.work) # disk image operations with open(Files.output, 'w') as f1, open(Files.reference, 'w') as f2: xdm(Disks.work, '-i', stdout=f2) xdm(Disks.work, '-q', stdout=f1) check_files_eq('CLI', Files.output, Files.reference, 'DIS/VAR255') ref_prog = os.path.join(Dirs.refs, 'prog00255') xdm(Disks.work, '-e', 'PROG00255', '-o', Files.output) check_files_eq('CLI', Files.output, ref_prog, 'PROGRAM') ref_dv = os.path.join(Dirs.refs, 'dv064x010') xdm(Disks.work, '-e', 'DV064X010', '-o', Files.output) check_files_eq('CLI', Files.output, ref_dv, 'DIS/VAR64') ref_df = os.path.join(Dirs.refs, 'df002x001') xdm(Disks.work, '-e', 'DF002X001', '-o', Files.output) check_files_eq('CLI', Files.output, ref_df, 'DIS/FIX 2') with open(Files.output, 'w') as f1: xdm(Disks.work, '-p', 'DV064X010', stdout=f1) check_files_eq('CLI', Files.output, ref_dv, 'DIS/VAR 64') with open(Files.error, 'w') as ferr: xdm(Disks.work, '-e', 'INVALID', stderr=ferr, rc=1) xdm(Disks.work, '-S', '0x01', '-o', Files.output) check_files_eq('CLI', Files.output, os.path.join(Dirs.refs, 'sector1'), 'DIS/VAR255') # add, rename, remove files shutil.copyfile(Disks.blank, Disks.work) xdm(Disks.work, '-a', ref_prog, ref_dv, ref_df) xdm(Disks.work, '-e', 'PROG00255', '-o', Files.output) check_files_eq('CLI', Files.output, ref_prog, 'PROGRAM') xdm(Disks.work, '-e', 'DV064X010', '-o', Files.output) check_files_eq('CLI', Files.output, ref_dv, 'PROGRAM') # use PROGRAM here to compare! shutil.copyfile(Disks.work, Disks.tifiles) xdm(Disks.work, '-e', 'PROG00255', '-o', Files.reference) xdm(Disks.work, '-r', 'PROG00255:OTHERNAME') xdm(Disks.work, '-e', 'OTHERNAME', '-o', Files.output) check_files_eq('CLI', Files.output, Files.reference, 'P') xdm(Disks.work, '-r', 'OTHERNAME:PROG00255') check_files_eq('CLI', Disks.work, Disks.tifiles, 'P') xdm(Disks.work, '-d', 'PROG00255', 'DV064X010', 'DF002X001') with open(Files.output, 'w') as f1, open(Files.reference, 'w') as f2: xdm(Disks.work, '-i', stdout=f1) xdm(Disks.blank, '-i', stdout=f2) check_files_eq('CLI', Files.output, Files.reference, 'DIS/VAR255') shutil.copyfile(Disks.recsgen, Disks.work) xdm(Disks.work, '-e', 'DF127*', 'PROG00001', 'PROG00002') if (not os.path.isfile('df127x001') or not os.path.isfile('df127x010') or not os.path.isfile('df127x020p')): error('CLI', 'DF127*: Missing files') xdm(Disks.work, '-d', 'PROG*', 'D?010X060') with open(Files.error, 'w') as ferr: xdm(Disks.work, '-e', 'PROG00255', stderr=ferr, rc=1) xdm(Disks.work, '-e', 'DV010X060', stderr=ferr, rc=1) xdm(Disks.work, '-e', 'DF010X060', stderr=ferr, rc=1) # multi-file naming xdm(Disks.work, '-n', 'MULTI', '-a', 'prog00001', ref_prog, 'prog00002') xdm(Disks.work, '-e', 'MULTI', '-o', Files.output) check_files_eq('CLI', 'prog00001', Files.output, 'P') xdm(Disks.work, '-e', 'MULTJ', '-o', Files.output) check_files_eq('CLI', ref_prog, Files.output, 'P') xdm(Disks.work, '-e', 'MULTK', '-o', Files.output) check_files_eq('CLI', 'prog00002', Files.output, 'P') xdm('-T', 'prog00001', ref_prog, 'prog00002', '-n', 'MULTFI') # -n applies to internal names! xdm(Disks.work, '-t', '-a', 'prog00001.tfi', ref_prog + '.tfi', 'prog00002.tfi') xdm(Disks.work, '-e', 'MULTFI', '-o', Files.output) check_files_eq('CLI', 'prog00001', Files.output, 'P') xdm(Disks.work, '-e', 'MULTFJ', '-o', Files.output) check_files_eq('CLI', ref_prog, Files.output, 'P') xdm(Disks.work, '-e', 'MULTFK', '-o', Files.output) check_files_eq('CLI', 'prog00002', Files.output, 'P') xdm('-T', ref_prog, 'prog00002', '-9', '-n', 'MULV9T') xdm(Disks.work, '-9', '-a', ref_prog + '.v9t9', 'prog00002.v9t9') xdm(Disks.work, '-e', 'MULV9T', '-o', Files.output) check_files_eq('CLI', ref_prog, Files.output, 'P') xdm(Disks.work, '-e', 'MULV9U', '-o', Files.output) check_files_eq('CLI', 'prog00002', Files.output, 'P') ref = os.path.join(Dirs.refs, 'glob') xdm(Disks.work, '-a', ref + '?', '-n', 'GLOBA1', shell=True) xdm(Disks.work, '-e', 'GLOBA1', '-o', Files.output) xdm(Disks.work, '-e', 'GLOBA2', '-o', Files.output) with open(Files.error, 'w') as ferr: xdm(Disks.work, '-e', 'GLOBA3', '-o', Files.output, stderr=ferr, rc=1) xdm(Disks.work, '-d', 'GLOB*', '-o', Files.output) xdm(Disks.work, '-a', ref + '*', '-n', 'GLOBB1', shell=True) xdm(Disks.work, '-e', 'GLOBB1', '-o', Files.output) xdm(Disks.work, '-e', 'GLOBB2', '-o', Files.output) xdm(Disks.work, '-e', 'GLOBB3', '-o', Files.output) # initialize disk xdm(Disks.work, '--initialize', '360', '-n', 'SSSD') check_file_size(Disks.work, 360 * 256) check_files_eq('CLI', Disks.work, Disks.blank, 'P') os.remove(Disks.work) xdm(Disks.work, '--initialize', 'SSSD', '-n', 'SSSD') check_file_size(Disks.work, 360 * 256) check_files_eq('CLI', Disks.work, Disks.blank, 'P') xdm(Disks.work, '--initialize', '800', '-n', 'INIT') with open(Files.output, 'w') as f: xdm(Disks.work, '-i', '-q', stdout=f) check_file_matches(Files.output, [(0, '\s2\s+used\s+798\s+free\s')]) os.remove(Disks.work) xdm(Disks.work, '--initialize', 'CF', '-n', 'INIT', '-q') with open(Files.output, 'w') as f: xdm(Disks.work, '-i', '-q', stdout=f) check_file_matches(Files.output, [(0, '\s2\s+used\s+1598\s+free\s')]) with open(Files.error, 'w') as ferr: xdm(Disks.work, '--initialize', '1', stderr=ferr, rc=1) xdm(Disks.work, '--initialize', '1601', stderr=ferr, rc=1) xdm(Disks.work, '--initialize', 'FOO', stderr=ferr, rc=1) f = os.path.join(Dirs.refs, 'vardis') for n in ['AA', 'BB']: xdm(Disks.work, '--initialize', 'SSSD', '-a', f, '-n', n) with open(Files.output, 'w') as fout: xdm(Disks.work, '-i', stdout=fout) check_file_matches(Files.output, [(0, n + '\s+'), (2, n + '\s+')]) # set geometry xdm(Disks.work, '--initialize', '1600', '-n', 'GEO') for g, p in [('1S1D', '1S/1D\s+40T'), ('99T8D7S', '7S/8D\s+99T'), ('22TDD', '7S/2D\s+22T'), ('DSSD', '2S/1D\s+22T'), ('1T', '2S/1D\s+1T'), ('3D10T9S', '9S/3D\s+10T'), ('SDDS', '2S/1D\s+10T'), ('SS', '1S/1D\s+10T')]: xdm(Disks.work, '--set-geometry', g, '-q') with open(Files.output, 'w') as fout: xdm(Disks.work, '-i', '-q', stdout=fout) check_file_matches(Files.output, [(0, p)]) # resize disk shutil.copyfile(Disks.recsgen, Disks.work) for s in ['800', '248', '1600']: xdm(Disks.work, '-Z', s, '-q') for f in ['PROG02560', 'DF129X010', 'DV127X010', 'DV255X015P']: xdm(Disks.work, '-e', f, '-q', '-o', Files.output) xdm(Disks.recsgen, '-e', f, '-o', Files.reference) check_files_eq('CLI', Files.output, Files.reference, 'PROGRAM') with open(Files.error, 'w') as ferr: xdm(Disks.work, '-Z', '240', stderr=ferr, rc=1) xdm(Disks.work, '-Z', '1608', stderr=ferr, rc=1) # new geometry handling (v1.5.3) for c, g, p in [ ('--initialize', 'SSSD', r'358 free\s+90 KB\s+1S/1D\s+40T'), ('--resize', 'DS1D', r'718 free\s+180 KB\s+2S/1D\s+40T'), ('--set-geometry', '80T', r'718 free\s+180 KB\s+2S/1D\s+80T'), # geom mismatch ('--initialize', '408', r'406 free\s+102 KB\s+2S/1D\s+40T'), ('--resize', 'DSSD80T', r'1438 free\s+360 KB\s+2S/1D\s+80T'), ('--resize', '2DSS', r'718 free\s+180 KB\s+1S/2D\s+40T'), ('-Z', '208', r'206 free\s+52 KB\s+1S/2D\s+40T'), ('--set-geometry', 'SD80T', r'206 free\s+52 KB\s+1S/1D\s+80T'), ('-X', 'DSSD80T', r'1438 free\s+360 KB\s+2S/1D\s+80T'), ('--set-geometry', '20T', r'1438 free\s+360 KB\s+2S/1D\s+20T') ]: # geom mismatch xdm(Disks.work, c, g, '-q') with open(Files.output, 'w') as fout: xdm(Disks.work, '-i', '-q', stdout=fout) check_file_matches(Files.output, [(0, p)]) with open(Files.error, 'w') as ferr: xdm(Disks.work, '--initialize', 'SS80T', stderr=ferr, rc=1) xdm(Disks.work, '--resize', '2S', stderr=ferr, rc=1) xdm(Disks.work, '--resize', '80T', stderr=ferr, rc=1) xdm(Disks.work, '--set-geometry', '123', stderr=ferr, rc=1) # xdm99 vs real images rfile = os.path.join(Dirs.refs, 'ti-text') # TEXT D/V80 with open(Files.output, 'w') as fout, open(Files.error, 'w') as ferr: xdm(Disks.work, '-X', 'sssd', '-n', 'TI-DISK', stderr=ferr, rc=0) xdm(Disks.work, '-a', rfile, '-n', 'TEXT', '-f', 'dv80', stderr=ferr, rc=0) check_file_len(Files.error, max_lines=0) check_disks_eq(Disks.work, Disks.tisssd) xdm(Disks.work, '-X', 'dsdd', '-n', 'TI-DISK', stderr=ferr, rc=0) xdm(Disks.work, '-a', rfile, '-n', 'TEXT', '-f', 'dv80', stderr=ferr, rc=0) check_file_len(Files.error, max_lines=0) check_disks_eq(Disks.work, Disks.tidsdd) xdm(Disks.work, '-Z', 'sssd', stderr=ferr, rc=0) check_file_len(Files.error, max_lines=0) check_disks_eq(Disks.work, Disks.tisssd) xdm(Disks.work, '--set-geometry', 'ssdd', stderr=ferr, rc=0) # warn check_file_len(Files.error, min_lines=1, max_lines=1) xdm(Disks.work, '-i', stdout=fout, stderr=ferr, rc=0) # warn check_file_len(Files.error, min_lines=2, max_lines=2) xdm(Disks.work, '-Z', 'dsdd', stderr=ferr, rc=0) check_file_len(Files.error, max_lines=2) check_disks_eq(Disks.work, Disks.tidsdd) xdm(Disks.work, '--set-geometry', 'ssdd80t', stderr=ferr, rc=0) check_file_len(Files.error, max_lines=2) xdm(Disks.work, '-X', 'dssd80t', '-n', 'TI-DSSD80', stderr=ferr, rc=0) check_file_len(Files.error, max_lines=2) check_disks_eq(Disks.work, Disks.tidssd80) # repair disks shutil.copyfile(Disks.bad, Disks.work) with open(Files.output, 'w') as f1, open(Files.reference, 'w') as f2: xdm(Disks.work, '-C', stderr=f1, rc=1) xdm(Disks.work, '-R', stderr=f2) check_file_len(Files.output, min_lines=2) with open(Files.output, 'w') as f1: xdm(Disks.work, '-C', stderr=f1) check_file_len(Files.output, max_lines=0) # FIAD operations shutil.copyfile(Disks.recsgen, Disks.work) xdm(Disks.work, '-e', 'PROG00255', 'DV064X010', '-t') xdm(Disks.work, '-e', 'PROG00255', '-t', '-o', Files.output) check_files_eq('CLI', Files.output, 'prog00255.tfi', 'PROGRAM') xdm(Disks.work, '-e', 'DV064X010', '-t', '-o', Files.output) check_files_eq('CLI', Files.output, 'dv064x010.tfi', 'PROGRAM') with open(Files.output, 'w') as f: xdm('-I', 'prog00255.tfi', 'dv064x010.tfi', stdout=f) xdm(Disks.work, '-e', 'PROG00255', 'DV064X010', '-9') xdm(Disks.work, '-e', 'PROG00255', '-9', '-o', Files.output) check_files_eq('CLI', Files.output, 'prog00255.v9t9', 'PROGRAM') xdm(Disks.work, '-e', 'DV064X010', '-9', '-o', Files.output) check_files_eq('CLI', Files.output, 'dv064x010.v9t9', 'PROGRAM') with open(Files.output, 'w') as f: xdm('-I', 'prog00255.v9t9', 'dv064x010.v9t9', stdout=f) xdm(Disks.work, '-e', 'PROG00255') xdm('-T', 'prog00255', '-o', Files.output) check_files_eq('CLI', Files.output, 'prog00255.tfi', 'PROGRAM', Masks.TIFile) xdm('-T', 'prog00255', '-9', '-o', Files.output) check_files_eq('CLI', Files.output, 'prog00255.v9t9', 'PROGRAM', Masks.v9t9) xdm(Disks.work, '-e', 'DV064X010', '-o', Files.reference) xdm('-F', 'dv064x010.tfi') check_files_eq('CLI', 'dv064x010', Files.reference, 'DIS/VAR 64') xdm('-F', 'dv064x010.tfi', '-o', Files.output) check_files_eq('CLI', Files.output, 'dv064x010', 'PROGRAM') xdm('-F', 'dv064x010.v9t9', '-9') check_files_eq('CLI', 'dv064x010', Files.reference, 'DIS/VAR 64') xdm('-F', 'dv064x010.v9t9', '-o', Files.output) check_files_eq('CLI', Files.output, 'dv064x010', 'PROGRAM') xdm('-T', 'dv064x010', '-o', Files.output, '-n', 'DV064X010', '-f', 'DIS/VAR 64') check_files_eq('CLI', Files.output, 'dv064x010.tfi', 'PROGRAM', Masks.TIFile) os.remove('dv064x010.tfi') xdm('-T', 'dv064x010', '-n', 'DV064X010', '-f', 'DIS/VAR 64') check_files_eq('CLI', 'dv064x010.tfi', Files.output, 'PROGRAM', Masks.TIFile) xdm('-T', 'dv064x010', '-9', '-o', Files.output, '-n', 'DV064X010', '-f', 'DIS/VAR 64') check_files_eq('CLI', Files.output, 'dv064x010.v9t9', 'PROGRAM', Masks.v9t9) os.remove('dv064x010.v9t9') xdm('-T', 'dv064x010', '-9', '-n', 'DV064X010', '-f', 'DIS/VAR 64') check_files_eq('CLI', 'dv064x010.v9t9', Files.output, 'PROGRAM', Masks.v9t9) # TI names shutil.copyfile(Disks.recsdis, Disks.work) xdm(Disks.work, '-t', '-e', 'F16', 'V16') xdm(Disks.work, '-t', '-e', 'F16', 'V16', '--ti-names') check_files_eq('TI names', 'F16', 'f16.tfi', 'PROGRAM') check_files_eq('TI names', 'V16', 'v16.tfi', 'PROGRAM') xdm(Disks.work, '-9', '-e', 'F1') xdm(Disks.work, '-9', '-e', 'F1', '--ti-names') check_files_eq('TI names', 'F1', 'f1.v9t9', 'PROGRAM') xdm(Disks.work, '-e', 'V1', '-o', Files.reference) xdm(Disks.work, '-e', 'V1', '--ti-names') check_files_eq('TI names', 'V1', Files.reference, 'PROGRAM') # conversion between TI/PC names ('.' vs '/') file1 = os.path.join(Dirs.refs, 'vardis') with open(os.path.join(Dirs.tmp, 'file.y.z'), 'wb') as f: f.write(b'\xff' * 100) xdm(Disks.work, '-X', 'sssd', '-a', file1, '-n', 'FILE.X') xdm(Disks.work, '-a', os.path.join(Dirs.tmp, 'file.y.z')) with open(Files.output, 'w') as fout: xdm(Disks.work, '-i', stdout=fout, rc=0) check_lines_start(Files.output, ('FILE/X', 'FILE/Y'), skip=1) xdm(Disks.work, '-r', 'FILE/X:NEW.FILE/X') with open(Files.output, 'w') as fout: xdm(Disks.work, '-i', stdout=fout, rc=0) check_lines_start(Files.output, ('NEW/FILE/X', 'FILE/Y'), skip=1) xdm(Disks.work, '-e', '*') check_file_exists('new.file.x') os.remove('new.file.x') check_file_exists('file.y') os.remove('file.y') xdm(Disks.work, '-e', 'FILE/Y', '-t') check_file_exists('file.y.tfi') os.remove('file.y.tfi') # rename disk (-n) xdm(Disks.work, '-X', 'sssd', '-n', 'FIRST.NAME') with open(Files.output, 'w') as fout: xdm(Disks.work, '-i', stdout=fout, rc=0) check_lines_start(Files.output, ('FIRST/NAME', )) xdm(Disks.work, '-n', 'SECND.NAME') with open(Files.output, 'w') as fout: xdm(Disks.work, '-i', stdout=fout, rc=0) check_lines_start(Files.output, ('SECND/NAME', )) # output directory -o <dir> ref1 = os.path.join(Dirs.refs, 'glob1') ref2 = os.path.join(Dirs.refs, 'glob12') xdm(Disks.work, '-X', 'sssd', '-a', ref1, ref2) xdm(Disks.work, '-e', 'GLOB*', '-o', Dirs.tmp) check_file_exists(os.path.join(Dirs.tmp, 'glob1')) os.remove(os.path.join(Dirs.tmp, 'glob1')) check_file_exists(os.path.join(Dirs.tmp, 'glob12')) os.remove(os.path.join(Dirs.tmp, 'glob12')) xdm(Disks.work, '-X', 'sssd', '-a', ref1, ref2) with open(Files.error, 'w') as ferr: xdm(Disks.work, '-e', 'GLOB*', '-o', Files.output, stderr=ferr, rc=1) # stdin and stdout ref = os.path.join(Dirs.refs, 'vardis') with open(ref, 'r') as fin: xdm(Disks.work, '--initialize', 'sssd', '-a', '-', '-f', 'dv40', stdin=fin) with open(Files.output, 'w') as fout: xdm(Disks.work, '-e', 'STDIN', '-o', '-', stdout=fout) check_files_eq('stdin/stdout', Files.output, ref, 'DV') ref = os.path.join(Dirs.refs, 'sector1') with open(Files.reference, 'wb') as fout: xdm(Disks.work, '--initialize', 'sssd', '-a', ref, '-n', 'T', '-o', '-', stdout=fout) with open(Files.reference, 'rb') as fin: xdm('-', '-e', 'T', '-o', Files.output, stdin=fin) check_files_eq('stdin/stdout', Files.output, ref, 'P') # usage errors with open(Files.error, 'w') as ferr: xdm('-a', Files.output, stderr=ferr, rc=2) xdm('-T', 'prog00001', 'prog00002', '-o', Files.output, stderr=ferr, rc=1) xdm('-T', 'prog00001', 'prog00002', '-9', '-o', Files.output, stderr=ferr, rc=1) xdm('-F', '-o', Files.output, stderr=ferr, rc=2) # cleanup os.remove(Files.output) os.remove(Files.reference) os.remove(Files.error) os.remove(Disks.work) os.remove(Disks.tifiles) for fn in [ 'prog00001', 'prog00002', 'df127x001', 'df127x010', 'df127x020p', 'prog00001.tfi', 'prog00002.tfi', 'prog00255.tfi', 'dv064x010.tfi', 'prog00002.v9t9', 'prog00255.v9t9', 'dv064x010.v9t9', 'F16', 'V16', 'f16.tfi', 'v16.tfi', 'F1', 'f1.v9t9', 'V1' ]: os.remove(fn)
def runtest(): """check reading and writing of random data""" # setup shutil.copyfile(Disks.blank, Disks.work) shutil.copyfile(Disks.blank, Disks.tifiles) # create files files = [] for count, length in [(1, 2), (300, 2), (60, 10), (10, 63), (10, 64), (10, 126), (1, 127), (10, 127), (10, 128), (10, 129), (1, 254), (5, 254), (1, 255), (5, 255)]: files.append(create_text_file(count, length, False, False)) files.append(create_text_file(count, length, True, False)) for count, length in [(20, 127), (15, 254), (15, 255)]: files.append(create_text_file(count, length, False, True)) files.append(create_text_file(count, length, True, True)) for size in [1, 2, 254, 255, 511, 513, 2560]: files.append(create_binary_file(size)) bigFiles = [] for count, length in [(200, 127), (100, 254), (100, 255)]: bigFiles.append(create_text_file(count, length, False, True)) bigFiles.append(create_text_file(count, length, True, True)) for size in [25600]: bigFiles.append(create_binary_file(size)) # add files one by one and check for name, path, fmt in files: xdm(Disks.work, "-a", path, "-f", fmt) xdm(Disks.work, "-e", name, "-o", Files.output) check_files_eq("Write records", Files.output, path, fmt) # remove files one by one and check for name, path, fmt in files: xdm(Disks.work, "-e", name, "-o", Files.output) check_files_eq("Write records", Files.output, path, fmt) xdm(Disks.work, "-d", name) # add all files for name, path, fmt in files: xdm(Disks.work, "-a", path, "-f", fmt) # extract in and convert to/from TIFiles format for name, path, fmt in files: xdm(Disks.work, "-e", name, "-o", Files.reference) xdm(Disks.work, "-e", name, "-t", "-o", Files.tifile) xdm("-F", Files.tifile, "-o", Files.output) check_files_eq("Write records", Files.output, Files.reference, fmt) xdm("-T", Files.reference, "-o", Files.output, "-f", fmt, "-n", name) check_files_eq("Write records", Files.output, Files.tifile, "PROGRAM", [(0x1e, 0x26)]) # add and remove TIFiles files for name, path, fmt in files: xdm(Disks.work, "-e", name, "-t", "-o", Files.tifile) xdm(Disks.tifiles, "-t", "-a", Files.tifile) check_files_eq("Write records", Disks.tifiles, Disks.work, "P") # convert to and from TIFiles cycle for name, fmt in [("intvar32v", "IV32"), ("intfix32v", "IF32"), ("vardis", "dv40")]: path = os.path.join(Dirs.refs, name) xdm(Disks.work, "-a", path, "-f", fmt, "-n", "T") xdm(Disks.work, "-e", "T", "-t", "-o", Files.output) xdm(Disks.work, "-d", "T") xdm(Disks.work, "-a", Files.output, "-t") xdm(Disks.work, "-e", "T", "-o", Files.output) check_text_files_eq("TIFiles", Files.output, path) # add and remove big files for name, path, fmt in bigFiles: xdm(Disks.work, "-a", path, "-f", fmt) xdm(Disks.work, "-e", name, "-o", Files.output) check_files_eq("Write records", Files.output, path, fmt) xdm(Disks.work, "-d", name) # check truncating of DIS/VAR files with long records path = os.path.join(Dirs.refs, "vardis") with open(path, "r") as f: reflines = f.readlines() for l in [8, 7, 4]: xdm(Disks.work, "-a", path, "-f", "DV%d" % l, "-q") xdm(Disks.work, "-e", "VARDIS", "-o", Files.output) check_trunc(Files.output, reflines, l) # create well-defined TI disk (checked-in state frozen) shutil.copyfile(Disks.recsgen, Disks.work) for name, path, fmt in files: xdm(Disks.work, "-a", path, "-f", fmt) # remove temporary files for name, path, fmt in files + bigFiles: os.remove(path) os.remove(Files.output) os.remove(Files.tifile) os.remove(Files.reference) os.remove(Disks.work) os.remove(Disks.tifiles)
def runtest(): """check xdt99 extensions""" # xdt99 extensions source = os.path.join(Dirs.sources, "asxext.asm") xas(source, "-R", "-o", Files.output) xdm(Disks.asmsrcs, "-e", "ASXEXT0-O", "-o", Files.reference) check_obj_code_eq(Files.output, Files.reference) xas(source, "-R", "-D", "sym2", "-o", Files.output) xdm(Disks.asmsrcs, "-e", "ASXEXT1-O", "-o", Files.reference) check_obj_code_eq(Files.output, Files.reference) xas(source, "-R", "-D", "sym2=2", "sym3=2", "-o", Files.output) xdm(Disks.asmsrcs, "-e", "ASXEXT2-O", "-o", Files.reference) check_obj_code_eq(Files.output, Files.reference) xas(source, "-R", "-D", "sym2=2,sym3=2", "-o", Files.output) xdm(Disks.asmsrcs, "-e", "ASXEXT2-O", "-o", Files.reference) check_obj_code_eq(Files.output, Files.reference) # some CLI options source = os.path.join(Dirs.sources, "ashello.asm") xas(source, "--embed", "-R", "-o", Files.output) # misc new features for infile, reffile in [("asxnew.asm", "ASXNEW-O"), ("asmacs.asm", "ASMACS-O")]: source = os.path.join(Dirs.sources, infile) xas(source, "-o", Files.output) xdm(Disks.asmsrcs, "-e", reffile, "-o", Files.reference) check_obj_code_eq(Files.output, Files.reference) # SAVE directive source = os.path.join(Dirs.sources, "asxsave.asm") xas(source, "-b", "--base", "0xb000", "-o", Files.output) save1s = [Files.output + "_" + ext for ext in ["b000", "b020", "b030"]] check_concat_eq(save1s, os.path.join(Dirs.refs, "save1")) check_no_files([Files.output + "_b080"]) # bank switching: obsolete AORG addr, bank source = os.path.join(Dirs.sources, "asxbank1.asm") xas(source, "-b", "-w", "-o", Files.output) save2s = [ Files.output + "_" + ext for ext in ["0000", "6000_b0", "6000_b1", "6100_b0", "6200_b1", "6200_b2"] ] check_concat_eq(save2s, os.path.join(Dirs.refs, "save2")) check_no_files([Files.output + "_0000_b0", Files.output + "_6100_b1"]) source = os.path.join(Dirs.sources, "asxbank2.asm") xas(source, "-b", "-w", "-o", Files.output) save3s = [ Files.output + "_" + ext for ext in ["c000_b0", "c000_b1", "d000_b0", "e000_b1"] ] check_concat_eq(save3s, os.path.join(Dirs.refs, "save3")) check_no_files([ Files.output + "_" + ext for ext in ["c000", "d000", "d000_b1", "e000", "e000_b0"] ]) source = os.path.join(Dirs.sources, "asxsegm.asm") xas(source, "-b", "-w", "-o", Files.output) check_file_sizes([ (Files.output + "_" + ext, size) for ext, size in [("0000", 20), ("b000_b1", 14), ("b010_b1", 2), ("b012_b2", 6)] ]) # BANK directive source = os.path.join(Dirs.sources, "asdbank.asm") xas(source, "-b", "-R", "-o", Files.output) save4s = [Files.output + ext for ext in ["_6000_b0", "_6000_b1"]] check_concat_eq(save4s, os.path.join(Dirs.refs, "asdbank")) # cross-bank access source = os.path.join(Dirs.sources, "asxbank.asm") with open(Files.error, "w") as ferr: xas(source, "-b", "-R", "-o", Files.output, stderr=ferr, rc=0) # no error source = os.path.join(Dirs.sources, "asnxbank.asm") with open(Files.error, "w") as ferr: xas(source, "-b", "-R", "-o", Files.output, stderr=ferr, rc=1) # with errors # sections shared across banks source = os.path.join(Dirs.sources, "asshbank.asm") with open(Files.error, "w") as ferr: xas(source, "-b", "-R", "-o", Files.output, stderr=ferr, rc=1) # with errors act_errors = read_stderr(Files.error) exp_errors = get_source_markers(source, r";ERROR(:....)?") check_errors(exp_errors, act_errors) source = os.path.join(Dirs.sources, "asshbankx.asm") with open(Files.error, "w") as ferr: xas(source, "-b", "-R", "-o", Files.output, stderr=ferr, rc=0) # no error # data output (-t) source = os.path.join(Dirs.sources, "ashexdat.asm") xas(source, "-t", "a2", "-R", "-o", Files.output) xas(source, "-b", "-R", "-o", Files.reference) check_numeric_eq(Files.output, Files.reference) source = os.path.join(Dirs.sources, "asxtext.asm") xas(source, "-t", "a2", "-o", Files.output + "1") xas(source, "-t", "c4", "-o", Files.output + "2") xas(source, "-t", "b", "-o", Files.output + "3") xas(source, "-t", "a4", "-o", Files.output + "4") xas(source, "-t", "c", "-o", Files.output + "5") save5s = [Files.output + ext for ext in ["1", "2", "3", "4", "5"]] check_concat_eq(save5s, os.path.join(Dirs.refs, "asxtext")) # auto-generated constants (b#, w#) source = os.path.join(Dirs.sources, "asautogen.asm") xas(source, "-b", "-R", "-o", Files.output) source = os.path.join(Dirs.sources, "asautoman.asm") xas(source, "-b", "-R", "-o", Files.reference) check_binary_files_eq("autogen", Files.output, Files.reference) source = os.path.join(Dirs.sources, "asautorel.asm") xas(source, "-b", "-R", "-o", Files.output) # address is now >00xx instead of >a0xx with open(Files.reference, "rb+") as f: data = f.read() data = data.replace("\xa0", "\x00") f.seek(0) f.write(data) check_binary_files_eq("autogen", Files.output, Files.reference) # register LSB access (l#) source = os.path.join(Dirs.sources, "asxrlb.asm") with open(Files.error, "w") as ferr: xas(source, "-b", "-R", "-o", Files.output, stderr=ferr, rc=0) ref = os.path.join(Dirs.sources, "asxrlbn.asm") xas(ref, "-b", "-R", "-o", Files.reference) check_binary_files_eq("rlb", Files.output, Files.reference) act_errors = read_stderr(Files.error, include_warnings=True) exp_errors = get_source_markers(source, tag=r";WARN") check_errors(exp_errors, act_errors) # size modifier (s#) source = os.path.join(Dirs.sources, "assmod.asm") with open(Files.error, "w") as ferr: xas(source, "-b", "-R", "-o", Files.output, stderr=ferr, rc=0) ref = os.path.join(Dirs.sources, "assmodn.asm") xas(ref, "-b", "-R", "-o", Files.reference) check_binary_files_eq("s#", Files.output, Files.reference) with open(Files.error, "r") as ferr: if "TEXT4" not in ferr.read(): error("s#", "Missing warning about TEXT4") source = os.path.join(Dirs.sources, "assmode.asm") with open(Files.error, "w") as ferr: xas(source, "-b", "-R", "-o", Files.output, stderr=ferr, rc=1) act_errors = read_stderr(Files.error) exp_errors = get_source_markers(source, tag=r";ERROR") check_errors(exp_errors, act_errors) # floating-point numbers source = os.path.join(Dirs.sources, "asfloat.asm") xas(source, "-b", "-o", Files.output) ref = os.path.join(Dirs.refs, "asfloat.ref") check_binary_files_eq("float", Files.output, ref) # cleanup os.remove(Files.output) os.remove(Files.reference) for fn in set(save1s + save2s + save3s + save4s + save5s): os.remove(fn)
def runtest(): """check linked files object code against non-linked equivalent file object code NOTE: Programs commented out contain multiple xORGs, so the relocation of segments will lead to different object codes. """ for inp_file, opts, ref_file, compr_file, relaxed_check in [ ('asdirs.asm', [], 'ASDIRS-O', 'ASDIRS-C', False), ('asorg2.asm', [], 'ASORG2-O', None, False), ('asorg3.asm', [], 'ASORG3-O', None, False), ('asopcs.asm', [], 'ASOPCS-O', 'ASOPCS-C', False), ('asbss.asm', [], 'ASBSS-O', 'ASBSS-C', False), ('asbss2.asm', [], 'ASBSS2-O', None, False), ('asbss3.asm', [], 'ASBSS3-O', None, False), ('asbss4.asm', [], 'ASBSS4-O', None, False), ('ashellon.asm', ['-R'], 'ASHELLO-O', 'ASHELLO-C', False), ('ascopy.asm', [], 'ASCOPY-O', None, False), ('assize1.asm', [], 'ASSIZE1-O', 'ASSIZE1-C', False), ('asextsym.asm', [], 'ASEXTSYM-O', 'ASEXTSYM-C', False), #('asimg1.asm', [], 'ASIMG1-O', 'ASIMG1-C', False), ('asimg2.asm', [], 'ASIMG2-O', None, False), #('asimg3.asm', [], 'ASIMG3-OX', None, False), ('asreloc.asm', [], 'ASRELOC-O', None, False), ('asxorg.asm', [], 'ASXORG-O', None, True), # TODO: slightly different structure for linked code ('ascart.asm', ['-R'], 'ASCART-O', 'ASCART-C', False), ]: source = os.path.join(Dirs.sources, inp_file) xas(*[source] + opts + ['-q', '-o', Files.input]) xas('-l', Files.input, '-o', Files.output) xdm(Disks.asmsrcs, '-e', ref_file, '-o', Files.reference) tagfilter = b'BC' if relaxed_check else None # compare only B and C tags check_obj_code_eq(Files.output, Files.reference, tagfilter=tagfilter) # default xas('-ll', Files.input, '-o', Files.output) check_obj_code_eq(Files.output, Files.reference, tagfilter=tagfilter) # resolve conflicts if compr_file: # compressed object code xas(*[source] + opts + ['-C', '-q', '-o', Files.input]) xas('-l', Files.input, '-C', '-o', Files.output) xdm(Disks.asmsrcs, '-e', compr_file, '-o', Files.reference) check_obj_code_eq(Files.output, Files.reference, compressed=True) # parsing of object code source = os.path.join(Dirs.sources, 'asbssorg.asm') xas(source, '-o', Files.reference) xas('-l', Files.reference, '-o', Files.output) check_obj_code_eq(Files.output, Files.reference) # link multiple files library = os.path.join(Dirs.sources, 'aslink0b.asm') xas(library, '-q', '-o', Files.input) source = os.path.join(Dirs.sources, 'aslink0a.asm') xas(source, '-l', Files.input, '-q', '-o', Files.output) ref = os.path.join(Dirs.sources, 'aslink0.asm') xas(ref, '-o', Files.reference) check_obj_code_eq(Files.output, Files.reference) xas(source, '-ll', Files.input, '-q', '-o', Files.output) check_obj_code_eq(Files.output, Files.reference) xas(source, library) # name should be source.obj objname = 'aslink0a.obj' if not os.path.isfile(objname): error('multi-files', 'Bad output file for multiple inputs') library = os.path.join(Dirs.sources, 'aslink1b.asm') xas(library, '-R', '-D', 'x=1', '-q', '-o', Files.input) source = os.path.join(Dirs.sources, 'aslink1a.asm') xas(source, '-l', Files.input, '-R', '-D', 'x=1', '-q', '-o', Files.output) ref = os.path.join(Dirs.sources, 'aslink1.asm') xas(ref, '-R', '-D', 'x=1', '-q', '-o', Files.reference) check_obj_code_eq(Files.output, Files.reference) # link 3 files for x in ('a', 'b', 'c'): xas(os.path.join(Dirs.sources, 'aslink2' + x + '.asm'), '-q', '-o', Files.input + x) xas('-l', Files.input + 'a', Files.input + 'b', Files.input + 'c', '-q', '-b', '-o', Files.output) xas(os.path.join(Dirs.sources, 'aslink2.asm'), '-q', '-b', '-o', Files.reference) check_binary_files_eq('link', Files.output, Files.reference) xas('-ll', Files.input + 'a', Files.input + 'b', Files.input + 'c', '-q', '-b', '-o', Files.output) xas(os.path.join(Dirs.sources, 'aslink2.asm'), '-q', '-b', '-o', Files.reference) check_binary_files_eq('link', Files.output, Files.reference) # ditto with multiple source files sources = [ os.path.join(Dirs.sources, f'aslink1{x}.asm') for x in ('a', 'b') ] xas(*sources, '-R', '-D', 'x=1', '-q', '-o', Files.output) ref = os.path.join(Dirs.sources, 'aslink1.asm') xas(ref, '-R', '-D', 'x=1', '-q', '-o', Files.reference) check_obj_code_eq(Files.output, Files.reference) sources = [ os.path.join(Dirs.sources, f'aslink2{x}.asm') for x in ('a', 'b', 'c') ] xas(*sources, '-b', '-q', '-o', Files.output) ref = os.path.join(Dirs.sources, 'aslink2.asm') xas(ref, '-b', '-q', '-o', Files.reference) check_binary_files_eq('multi-source', Files.output, Files.reference) # link and multi-files with conflict source1 = os.path.join(Dirs.sources, 'aslink3a.asm') source2 = os.path.join(Dirs.sources, 'aslink3b.asm') xas(source1, source2, '-b', '-o', Files.output) ref = os.path.join(Dirs.sources, 'aslink3.asm') xas(ref, '-b', '-o', Files.reference) check_binary_files_eq('link', Files.output, Files.reference) xas(source2, '-o', Files.input) xas(source1, '-l', Files.input, '-b', '-o', Files.output) check_binary_files_eq('multi-source', Files.output, Files.reference) # link file with auto-generated constants source = os.path.join(Dirs.sources, 'asauto.asm') xas(source, '-R', '-o', Files.input) xas('-R', '-l', Files.input, '-b', '-o', Files.output) xas(source, '-R', '-b', '-o', Files.reference) check_binary_files_eq('link', Files.output, Files.reference) # link w/o name xas('-l', Files.input, '-R') if not os.path.isfile('a.obj'): error('link', 'Objcode code file with default name not found') # link and rebase source = os.path.join(Dirs.sources, 'aslinkr.asm') xas(source, '-q', '-o', Files.input) xas('-l', Files.input, '-a', '>2000', '-b', '-q', '-o', Files.output) xas(source, '-b', '-a', '>2000', '-o', Files.reference) check_binary_files_eq('link/base', Files.output, Files.reference) xas('-ll', Files.input, '-a', '>2000', '-b', '-q', '-o', Files.output) check_binary_files_eq('link/base', Files.output, Files.reference) # link and rorg/aorg lib = os.path.join(Dirs.sources, 'aslinkob.asm') xas(lib, '-o', Files.input) source = os.path.join(Dirs.sources, 'aslinkoa.asm') xas(source, '-a', '>4000', '-l', Files.input, '-o', Files.output) ref = os.path.join(Dirs.sources, 'aslinko.asm') xas(ref, '-o', Files.reference) check_obj_code_eq(Files.output, Files.reference) xas(source, lib, '-a', '>4000', '-o', Files.output) check_obj_code_eq(Files.output, Files.reference) xas(source, '-a', '>4000', '-ll', Files.input, '-o', Files.output) ref = os.path.join(Dirs.sources, 'aslinkor.asm') xas(ref, '-o', Files.reference) check_obj_code_eq(Files.output, Files.reference) # link and xorg lib = os.path.join(Dirs.sources, 'aslinkxb.asm') xas(lib, '-q', '-o', Files.input) source = os.path.join(Dirs.sources, 'aslinkxa.asm') xas(source, '-l', Files.input, '-q', '-o', Files.output) ref = os.path.join(Dirs.sources, 'aslinkx.asm') xas(ref, '-q', '-o', Files.reference) check_obj_code_eq(Files.output, Files.reference) xas(source, '-ll', Files.input, '-q', '-o', Files.output) check_obj_code_eq(Files.output, Files.reference) xas(source, '-l', Files.input, '-a', '>e000', '-b', '-q', '-o', Files.output) ref = os.path.join(Dirs.sources, 'aslinkxe.asm') xas(ref, '-b', '-q', '-o', Files.reference) check_binary_files_eq('link/xorg', Files.output, Files.reference) xas(source, '-ll', Files.input, '-a', '>e000', '-b', '-q', '-o', Files.output) ref = os.path.join(Dirs.sources, 'aslinkxer.asm') xas(ref, '-b', '-q', '-o', Files.reference) check_binary_files_eq('link/xorg', Files.output, Files.reference) # link and -D lib = os.path.join(Dirs.sources, 'aslink4b.asm') xas(lib, '-q', '-o', Files.input) source = os.path.join(Dirs.sources, 'aslink4a.asm') xas(source, '-l', Files.input, '-D', 'x=69', '-o', Files.output) # no need for -ll case ref = os.path.join(Dirs.sources, 'aslink4.asm') xas(ref, '-D', 'x=69', '-q', '-o', Files.reference) check_obj_code_eq(Files.output, Files.reference) # in-unit conflict resolution # NOTE: For one program unit, internal conflicts may still be resolved # against the absolute segments, yielding a non-zero offset for that # single unit. Inter-reloc conflicts cannot be resolved. source = os.path.join(Dirs.sources, 'asorgx.asm') xas(source, '-o', Files.input) xas('-ll', Files.input, '-b', '-o', Files.output) ref = os.path.join(Dirs.sources, 'asorgxn.asm') xas(ref, '-b', '-o', Files.reference) check_binary_files_eq('in-file conflict', Files.output, Files.reference) # symbol conflicts source1 = os.path.join(Dirs.sources, 'aslinks1a.asm') source2 = os.path.join(Dirs.sources, 'aslinks1b.asm') with open(Files.error, 'w') as ferr: xas(source1, source2, '-o', Files.output, rc=1, stderr=ferr) xas(source2, '-o', Files.input) with open(Files.error, 'w') as ferr: xas(source1, '-l', Files.input, '-o', Files.output, rc=1, stderr=ferr) source1 = os.path.join(Dirs.sources, 'aslinks2a.asm') xas(source1, source2, '-o', Files.output, rc=0) source2 = os.path.join(Dirs.sources, 'aslinks2b.asm') xas(source1, source2, '-o', Files.output, rc=0) xas(source2, '-o', Files.input) xas(source1, '-l', Files.input, '-o', Files.output, rc=0) # entry conflict source1 = os.path.join(Dirs.sources, 'aslinkea.asm') source2 = os.path.join(Dirs.sources, 'aslinkeb.asm') with open(Files.error, 'w') as ferr: xas(source1, source2, '-o', Files.output, rc=1, stderr=ferr) xas(source2, '-o', Files.input) with open(Files.error, 'w') as ferr: xas(source1, '-l', Files.input, '-o', Files.output, rc=1, stderr=ferr) # practical example source = os.path.join(Dirs.sources, 'asstdlib.asm') libs = ['vmbw.a99', 'vsbr.a99', 'vwbt.a99'] with open(Files.error, 'w') as ferr: xas(source, *libs, '-R', '-o', Files.output, rc=0, stderr=ferr) check_file_empty(Files.error) # cleanup os.remove(Files.input) os.remove(Files.input + 'a') os.remove(Files.input + 'b') os.remove(Files.input + 'c') os.remove(Files.output) os.remove(Files.reference) os.remove(objname) os.remove('a.obj')
def runtest(): """compare extracted files to reference files""" # compare with reference files generated by TI Image Tool shutil.copyfile(Disks.recsdis, Disks.work) for fn in [ "V1", "V16", "V126", "V127", "V128", "V254", "V10R", "V64V", "V255V1", "V255V2", "V255V3", "V255V4", "V255V5", # NOTE: F1.tfi has incorrect record count "F16", "F127", "F128", "F129", "F254", "F255", "F64V", "F10R" ]: xdm(Disks.work, "-e", fn, "-t", "-o", Files.output) checkFilesEq("TIFiles", Files.output, os.path.join(Dirs.refs, fn + ".tfi"), "PROGRAM", Masks.TIFile) # compare with reference files generated by Classic99 for fn in [ "V16", "V127", "V64V", "V10R", "F129", "F64V", "F10R" ]: xdm(Disks.work, "-e", fn, "-9", "-o", Files.output) checkFilesEq("v9t9", Files.output, os.path.join(Dirs.refs, fn + ".v9t9"), "PROGRAM", Masks.v9t9) xdm("-F", Files.output, "-9", "-o", Files.output) xdm(Disks.work, "-e", fn, "-o", Files.reference) checkFilesEq("v9t9", Files.output, Files.reference, "DV") # compare files extracted from fragmented image shutil.copyfile(Disks.frag, Disks.work) for fn in ["F1", "F6"]: xdm(Disks.work, "-e", fn, "-o", Files.output) checkFilesEq("Frag Disk", Files.output, os.path.join(Dirs.refs, "FRAG" + fn), "DIS/VAR127") xdm(Disks.work, "-d", "F1") xdm(Disks.work, "-e", "F6", "-o", Files.output) checkFilesEq("Frag Disk", Files.output, os.path.join(Dirs.refs, "FRAGF6"), "DIS/VAR127") shutil.copyfile(Disks.frag, Disks.work) xdm(Disks.work, "-a", Files.output, "-n", "COPY", "-f", "DIS/VAR127") xdm(Disks.work, "-e", "F1", "-o", Files.output) checkFilesEq("Frag Disk", Files.output, os.path.join(Dirs.refs, "FRAGF1"), "DIS/VAR127") # cleanup os.remove(Files.output) os.remove(Disks.work)
def runtest(): """extract INT record files generated by WRITEINT.bas""" # setup shutil.copyfile(Disks.recsint, Disks.work) # read full-size records for reclen in [2, 64, 127, 128, 254, 255]: xdm(Disks.work, '-e', 'IF' + str(reclen), '-o', Files.output) check_records_by_checksum(Files.output, reclen, True) xdm(Disks.work, '-e', 'IV' + str(reclen), '-o', Files.output) check_records_by_checksum(Files.output, reclen, False) # read partially filled records for fn in ['intfix32v', 'intvar32v', 'intfix128v', 'intvar128v']: xdm(Disks.work, '-e', fn.upper(), '-o', Files.output) ref = os.path.join(Dirs.refs, fn) check_files_eq('INT Records', Files.output, ref, 'P') # re-write extracted records and check for reclen in [2, 64, 127, 128, 254, 255]: xdm(Disks.work, '-e', 'IF' + str(reclen), '-o', Files.reference) xdm(Disks.work, '-a', Files.reference, '-n', 'CF' + str(reclen), '-f', 'INT/FIX' + str(reclen)) xdm(Disks.work, '-e', 'CF' + str(reclen), '-o', Files.output) check_files_eq('Write INT', Files.output, Files.reference, 'INT/FIX' + str(reclen)) xdm(Disks.work, '-e', 'IV' + str(reclen), '-o', Files.reference) xdm(Disks.work, '-a', Files.reference, '-n', 'CV' + str(reclen), '-f', 'INT/VAR' + str(reclen)) xdm(Disks.work, '-e', 'CV' + str(reclen), '-o', Files.output) check_files_eq('Write INT', Files.output, Files.reference, 'INT/VAR' + str(reclen)) # re-write partially filled records for fn, fmt in [ ('intfix32v', 'IF32'), ('intvar32v', 'IV32'), ('intfix128v', 'IF128'), ('intvar128v', 'IV128') ]: ref = os.path.join(Dirs.refs, fn) xdm(Disks.work, '-a', ref, '-n', 'TEST', '-f', fmt) xdm(Disks.work, '-e', 'TEST', '-o', Files.output) check_files_eq('Write INT', Files.output, ref, 'P') # cleanup os.remove(Files.output) os.remove(Files.reference) os.remove(Disks.work)
def runtest(): """check xdt99 extensions""" # xdt99 extensions source = os.path.join(Dirs.sources, "asxext.asm") xas(source, "-R", "-o", Files.output) xdm(Disks.asmsrcs, "-e", "ASXEXT0-O", "-o", Files.reference) checkObjCodeEq(Files.output, Files.reference) xas(source, "-R", "-D", "sym2", "-o", Files.output) xdm(Disks.asmsrcs, "-e", "ASXEXT1-O", "-o", Files.reference) checkObjCodeEq(Files.output, Files.reference) xas(source, "-R", "-D", "sym2=2", "sym3=2", "-o", Files.output) xdm(Disks.asmsrcs, "-e", "ASXEXT2-O", "-o", Files.reference) checkObjCodeEq(Files.output, Files.reference) # some CLI options source = os.path.join(Dirs.sources, "ashello.asm") xas(source, "--embed", "-R", "-o", Files.output) # misc new features for infile, reffile in [ ("asxnew.asm", "ASXNEW-O"), ("asmacs.asm", "ASMACS-O") ]: source = os.path.join(Dirs.sources, infile) xas(source, "-o", Files.output) xdm(Disks.asmsrcs, "-e", reffile, "-o", Files.reference) checkObjCodeEq(Files.output, Files.reference) # SAVE directive source = os.path.join(Dirs.sources, "asxsave.asm") xas(source, "-b", "--base", "0xb000", "-o", Files.output) save1s = [Files.output + "_" + ext for ext in ["b000", "b020", "b030"]] checkConcatEq(save1s, os.path.join(Dirs.refs, "save1")) checkNoFiles([Files.output + "_b080"]) # bank switching source = os.path.join(Dirs.sources, "asxbank1.asm") xas(source, "-b", "-o", Files.output) save2s = [Files.output + "_" + ext for ext in ["0000", "6000_b0", "6000_b1", "6100_b0", "6200_b1", "6200_b2"]] checkConcatEq(save2s, os.path.join(Dirs.refs, "save2")) checkNoFiles([Files.output + "_" + ext for ext in ["0000_b0", "6000", "6100_b1", "6200_b0"]]) source = os.path.join(Dirs.sources, "asxbank2.asm") xas(source, "-b", "-o", Files.output) save3s = [Files.output + "_" + ext for ext in ["c000", "c000_b0", "c000_b1", "d000_b0", "e000_b1"]] checkConcatEq(save3s, os.path.join(Dirs.refs, "save3")) checkNoFiles([Files.output + "_" + ext for ext in ["d000", "d000_b1", "e000", "e000_b0"]]) source = os.path.join(Dirs.sources, "asxsegm.asm") xas(source, "-b", "-o", Files.output) checkFileSizes([(Files.output + "_" + ext, size) for ext, size in [("0000", 20), ("b000_b1", 14), ("b010_b1", 2), ("b012_b2", 6)]]) # cleanup os.remove(Files.output) os.remove(Files.reference) for fn in save1s + save2s + save3s: os.remove(fn)
def runtest(): """check error messages against native assembler listing""" # cross-assembler error messages source = os.path.join(Dirs.sources, 'aserrs.asm') with open(Files.error, 'w') as ferr: xas(source, '-s', '-o', Files.output, stderr=ferr, rc=1) xas_errors = read_stderr(Files.error) # TI assembler error messages ti_errors = [] xdm(Disks.asmsrcs, '-e', 'ASERRS-L', '-o', Files.reference) with open(Files.reference, 'r') as f: for line in f: err = re.match(r'\*{5}\s+([A-Z ]*) - (\d+)', line) if err: lino = err.group(2) ti_errors.append(lino) # compare check_errors(ti_errors, xas_errors) # xdt99-specific errors source = os.path.join(Dirs.sources, 'asxerrs.asm') with open(Files.error, 'w') as ferr: xas(source, '-R', '-o', Files.output, stderr=ferr, rc=1) xas_errors = read_stderr(Files.error) ref_errors = get_source_markers(source, r';ERROR(:....)?') check_errors(ref_errors, xas_errors) # xdt99-specific errors (image generation) source = os.path.join(Dirs.sources, 'asxerrsb.asm') with open(Files.error, 'w') as ferr: xas(source, '-R', '-b', '-o', Files.output, stderr=ferr, rc=1) xas_errors = read_stderr(Files.error) ref_errors = get_source_markers(source, tag=r';ERROR(:....)?') check_errors(ref_errors, xas_errors) # open .if-.endif or .defm-.endm source = os.path.join(Dirs.sources, 'asopenif.asm') with open(Files.error, 'w') as ferr: xas(source, '-o', Files.output, stderr=ferr, rc=1) with open(Files.error, 'r') as fin: msgs = ' '.join(fin.readlines()) if 'Missing .endif' not in msgs: error('open', 'Missing error for open .if/.endif') source = os.path.join(Dirs.sources, 'asopenmac.asm') with open(Files.error, 'w') as ferr: xas(source, '-o', Files.output, stderr=ferr, rc=1) with open(Files.error, 'r') as fin: msgs = ' '.join(fin.readlines()) if 'Missing .endm' not in msgs: error('open', 'Missing error for open .defm/.endm') # files not found source = os.path.join(Dirs.sources, 'ascopyi.asm') with open(Files.error, 'w') as ferr: xas(source, '-o', Files.output, stderr=ferr, rc=1) # warnings source = os.path.join(Dirs.sources, 'aswarn.asm') with open(Files.error, 'w') as ferr: xas(source, '-b', '-R', '-o', Files.output, stderr=ferr, rc=0) # no error act_errors = read_stderr(Files.error, include_warnings=True) exp_errors = get_source_markers(source, tag=r';WARN') check_errors(exp_errors, act_errors) source = os.path.join(Dirs.sources, 'asuusym.asm') # undefined symbols with open(Files.error, 'w') as ferr: xas(source, '-R', '-o', Files.output, stderr=ferr, rc=0) # no error with open(Files.error, 'r') as fin: output = fin.read() if output.strip()[-18:] != 'U1, U2, U3, U4, U5': error('stdout', 'Bad listing of unreferenced symbols') with open(Files.error, 'w') as ferr: xas(source, '-R', '-q', '-o', Files.output, stderr=ferr, rc=0) # no error with open(Files.error, 'r') as fin: output = fin.read() if output.strip(): error('stdout', 'Unwanted listing of unreferenced symbols') # STDOUT source = os.path.join(Dirs.sources, 'asstdout.asm') with open(Files.error, 'w') as fout: xas(source, '-b', '-R', '-o', Files.output, stdout=fout, rc=0) # no error with open(Files.error, 'r') as fin: output = fin.read() if output.strip() != 'hello 42 world!': error('stdout', 'Invalid STDOUT output: ' + output) # cleanup os.remove(Files.error) os.remove(Files.reference)
def runtest(): """check command line interface""" # conversion HFE <-> disk pseudo-disks for n in ["rsssd", "rdssd", "rssdd", "rdsdd", "rsssd80t", "rdssd80t", "tiit80t"]: refdsk = os.path.join(Dirs.hfe, n + ".dsk") refhfe = os.path.join(Dirs.hfe, n + "_dsk.hfe.gz") with gzip.open(refhfe, "rb") as fin, open(Files.reference, "wb") as fout: fout.write(fin.read()) xhm("-T", refdsk, "-o", Files.input) checkFilesEq("HFE", Files.input, Files.reference, "PROGRAM") xhm("-F", Files.input, "-o", Files.output) checkFilesEq("HFE", Files.output, refdsk, "PROGRAM") # xdm99 delegation with gzip.open(Disks.hfe, "rb") as fin, open(Disks.work, "wb") as fout: fout.write(fin.read()) with open(Files.output, "w") as fout: xhm(Disks.work, stdout=fout) checkFileContains(Files.output, "HFEDISK.*1S/1D.*40") checkFileContains(Files.output, "HFEFILE") # image manipulation ref = os.path.join(Dirs.refs, "ti-text") xhm(Disks.work, "-a", ref, "-n", "TESTFILE", "-f", "DV60") xhm(Disks.work, "-e", "TESTFILE", "-o", Files.output) xhm("-o", Files.output, Disks.work, "-e", "TESTFILE") checkFilesEq("HFE", Files.output, ref, "PRORGAM") with open(Files.output, "wb") as fout: xhm(Disks.work, "-p", "TESTFILE", stdout=fout) checkFilesEq("HFE", Files.output, ref, "PRORGAM") ref = os.path.join(Dirs.refs, "V10R.tfi") shutil.copyfile(ref, Files.reference) xhm(Disks.work, "-a", Files.reference, "-t") xhm(Disks.work, "-e", "V10R", "-o", Files.output) xhm("-o", Files.output, Disks.work, "-e", "V10R") ref = os.path.join(Dirs.refs, "v10r.txt") checkFilesEq("HFE", Files.output, ref, "PRORGAM") # image resize with open(Files.output, "w") as fout: xhm("--hfe-info", Disks.work, stdout=fout) checkFileContains(Files.output, "Tracks: 40") checkFileContains(Files.output, "Sides: 1") checkFileContains(Files.output, "Encoding: 2") # SD xhm(Disks.work, "-Z", "dsdd") with open(Files.output, "w") as fout: xhm("--hfe-info", Disks.work, stdout=fout) checkFileContains(Files.output, "Tracks: 40") checkFileContains(Files.output, "Sides: 2") checkFileContains(Files.output, "Encoding: 0") # DD # image creation xhm(Disks.work, "-X", "dssd80t", "-a", ref, "-n", "WALDO") with open(Files.output, "w") as fout: xhm(Disks.work, "-i", stdout=fout) checkFileContains(Files.output, "2S/1D\s+80") checkFileContains(Files.output, "WALDO.*PROGRAM") with open(Files.output, "w") as fout: xhm("--hfe-info", Disks.work, stdout=fout) checkFileContains(Files.output, "Tracks: 80") checkFileContains(Files.output, "Sides: 2") checkFileContains(Files.output, "Encoding: 2") # SD # messy stuff xdm(Disks.work, "-X", "sssd") xdm(Disks.work, "--set-geometry", "dssd") # image too short now! xhm("-T", Disks.work, "-o", Files.input) with open(Files.output, "w") as fout: xhm("--hfe-info", Files.input, stdout=fout) checkFileContains(Files.output, "Tracks: 40") checkFileContains(Files.output, "Sides: 2") # DS checkFileContains(Files.output, "Encoding: 2") # SD with open(Files.error, "w") as ferr: # quelch error msg xhm(Files.input, stderr=ferr, rc=1) # invalid track count # cleanup os.remove(Files.input) os.remove(Files.output) os.remove(Files.reference) os.remove(Files.error) os.remove(Disks.work)
def runtest(): """extract VAR record files generated by DMWRVAR.xb""" # setup shutil.copyfile(Disks.recsdis, Disks.work) # read full-size records for reclen in [16, 127, 128, 129, 254, 255]: xdm(Disks.work, "-e", "F" + str(reclen), "-o", Files.output) checkRecordsByChecksum(Files.output) for reclen in [16, 126, 127, 128, 254, 255]: xdm(Disks.work, "-e", "V" + str(reclen), "-o", Files.output) checkRecordsByChecksum(Files.output) # read partially filled records for reclen in [64]: xdm(Disks.work, "-e", "F" + str(reclen) + "V", "-o", Files.output) checkRecordsByLen(Files.output, fixed=reclen) for recid in [ "64V", "255V1", "255V2", "255V3", "255V4", "255V4", "255V5" ]: xdm(Disks.work, "-e", "V" + recid, "-o", Files.output) checkRecordsByLen(Files.output) # read special records xdm(Disks.work, "-e", "F10R", "-o", Files.output) checkFilesEq("VAR Records", Files.output, os.path.join(Dirs.refs, "f10r.txt"), "DIS/FIX10") xdm(Disks.work, "-e", "V10R", "-o", Files.output) checkFilesEq("VAR Records", Files.output, os.path.join(Dirs.refs, "v10r.txt"), "DIS/VAR10") # re-write extracted records and check for fn in [ "V1", "V16", "V126", "V127", "V128", "V254", "V64V", "V255V1", "V255V2", "V255V3", "V255V4", "V255V5", "V10R", "F10R", "F1", "F16", "F127", "F128", "F129", "F254", "F255", "F64V" ]: rectype = "DIS/VAR" if fn[0] == "V" else "DIS/FIX" reclen = re.search("\d+", fn).group(0) fmt = rectype + reclen xdm(Disks.work, "-e", fn, "-o", Files.reference) xdm(Disks.work, "-a", Files.reference, "-n", "COPY", "-f", fmt) xdm(Disks.work, "-e", "COPY", "-o", Files.output) checkFilesEq("VAR Records", Files.output, Files.reference, fmt) # cleanup os.remove(Files.output) os.remove(Files.reference) os.remove(Disks.work)
def runtest(): """compare extracted files to reference files""" # compare with reference files generated by TI Image Tool shutil.copyfile(Disks.recsdis, Disks.work) for fn in [ "V1", "V16", "V126", "V127", "V128", "V254", "V10R", "V64V", "V255V1", "V255V2", "V255V3", "V255V4", "V255V5", # NOTE: F1.tfi has incorrect record count "F16", "F127", "F128", "F129", "F254", "F255", "F64V", "F10R" ]: xdm(Disks.work, "-e", fn, "-t", "-o", Files.output) checkFilesEq("TIFiles", Files.output, os.path.join(Dirs.refs, fn + ".tfi"), "PROGRAM", Masks.TIFile) # compare with reference files generated by Classic99 for fn in ["V16", "V127", "V64V", "V10R", "F129", "F64V", "F10R"]: xdm(Disks.work, "-e", fn, "-9", "-o", Files.output) checkFilesEq("v9t9", Files.output, os.path.join(Dirs.refs, fn + ".v9t9"), "PROGRAM", Masks.v9t9) xdm("-F", Files.output, "-9", "-o", Files.output) xdm(Disks.work, "-e", fn, "-o", Files.reference) checkFilesEq("v9t9", Files.output, Files.reference, "DV") # compare files extracted from fragmented image shutil.copyfile(Disks.frag, Disks.work) for fn in ["F1", "F6"]: xdm(Disks.work, "-e", fn, "-o", Files.output) checkFilesEq("Frag Disk", Files.output, os.path.join(Dirs.refs, "FRAG" + fn), "DIS/VAR127") xdm(Disks.work, "-d", "F1") xdm(Disks.work, "-e", "F6", "-o", Files.output) checkFilesEq("Frag Disk", Files.output, os.path.join(Dirs.refs, "FRAGF6"), "DIS/VAR127") shutil.copyfile(Disks.frag, Disks.work) xdm(Disks.work, "-a", Files.output, "-n", "COPY", "-f", "DIS/VAR127") xdm(Disks.work, "-e", "F1", "-o", Files.output) checkFilesEq("Frag Disk", Files.output, os.path.join(Dirs.refs, "FRAGF1"), "DIS/VAR127") # compare short and long TIFiles rfile = os.path.join(Dirs.refs, "V64V") shutil.copyfile(rfile, Files.reference) with open(Files.output, "w") as f: xdm(Disks.work, "-I", Files.reference, stdout=f) checkFileMatches(Files.output, [ (0, "^%-10s" % tiname(Files.reference) + r"\s+4 DIS/VAR 64\s+575 B\s+9 recs\s+" + str(datetime.date.today())) ]) xdm(Disks.work, "-X", "sssd", "-t", "-a", rfile) xdm(Disks.work, "-e", "V64V", "-o", Files.output) xdm("-F", rfile, "-o", Files.reference) checkFilesEq("Short TIFiles", Files.output, Files.reference, "DIS/VAR64") # cleanup os.remove(Files.output) os.remove(Disks.work)
def runtest(): """check cross-generated output against native reference files""" # object code for inp_file, opts, ref_file, compr_file in [ ('asdirs.asm', [], 'ASDIRS-O', 'ASDIRS-C'), ('asorgs.asm', [], 'ASORGS-O', 'ASORGS-C'), ('asopcs.asm', [], 'ASOPCS-O', 'ASOPCS-C'), ('asexprs.asm', [], 'ASEXPRS-O', None), ('asbss.asm', [], 'ASBSS-O', 'ASBSS-C'), ('asregs.asm', ['-R'], 'ASREGS-O', 'ASREGS-C'), ('ashellon.asm', ['-R'], 'ASHELLO-O', 'ASHELLO-C'), ('ascopy.asm', [], 'ASCOPY-O', None), ('ascopyn.asm', [], 'ASCOPYN-O', None), ('assize1.asm', [], 'ASSIZE1-O', 'ASSIZE1-C'), ('assize2.asm', [], 'ASSIZE2-O', None), ('assize3.asm', [], 'ASSIZE3-O', None), ('assize4.asm', [], 'ASSIZE4-O', None), ('asextsym.asm', [], 'ASEXTSYM-O', None), ('asdorg.asm', [], 'ASDORG-O', None), ('asrorg.asm', [], 'ASRORG-O', None), ('asimg1.asm', [], 'ASIMG1-O', 'ASIMG1-C'), ('asimg2.asm', [], 'ASIMG2-O', None), ('asimg3.asm', [], 'ASIMG3-OX', None), ('asreloc.asm', [], 'ASRELOC-O', None), ('asxorg.asm', [], 'ASXORG-O', None), ('ascart.asm', ['-R'], 'ASCART-O', 'ASCART-C') ]: source = os.path.join(Dirs.sources, inp_file) xdm(Disks.asmsrcs, '-e', ref_file, '-o', Files.reference) xas(*[source] + opts + ['-q', '-o', Files.output]) check_obj_code_eq(Files.output, Files.reference) xas(*[source] + opts + ['--strict', '-q', '-o', Files.output]) check_obj_code_eq(Files.output, Files.reference) if compr_file: # compressed object code xas(*[source] + opts + ['-C', '-q', '-o', Files.output]) xdm(Disks.asmsrcs, '-e', compr_file, '-o', Files.reference) check_obj_code_eq(Files.output, Files.reference, compressed=True) # image files for inp_file, ref_file in [('asimg1.asm', 'ASIMG1-I'), ('asimg2.asm', 'ASIMG2-I'), ('asimg3.asm', 'ASIMG3-I')]: source = os.path.join(Dirs.sources, inp_file) xas(source, '-i', '-o', Files.output) xdm(Disks.asmsrcs, '-e', ref_file, '-o', Files.reference) check_image_files_eq(Files.output, Files.reference) for inp_file, reffiles in [ ('aslimg.asm', ['ASLIMG-I', 'ASLIMG-J', 'ASLIMG-K']), ('assimg.asm', ['ASSIMG-I', 'ASSIMG-J', 'ASSIMG-K', 'ASSIMG-L']), ('asreloc.asm', ['ASRELOC-I']) ]: source = os.path.join(Dirs.sources, inp_file) xas(source, '-R', '-i', '-q', '-o', Files.output) gendata = [] refdata = [] for i, ref_file in enumerate(reffiles): xdm(Disks.asmimgs, '-e', ref_file, '-o', Files.reference) with open(Files.outputff[i], 'rb') as fgen, open(Files.reference, 'rb') as fref: gendata.append(fgen.read()) refdata.append(fref.read()) check_image_set_eq(gendata, refdata) # JMP instruction source = os.path.join(Dirs.sources, 'asjmp.asm') with open(Files.error, 'w') as ferr: xas(source, '-o', Files.output, stderr=ferr, rc=1) xaserrors = read_stderr(Files.error) referrors = get_source_markers(source, r';ERROR(:....)?') check_errors(referrors, xaserrors) # xas99-defined symbols source = os.path.join(Dirs.sources, 'asxassym.asm') xas(source, '-b', '-o', Files.output) with open(Files.output, 'rb') as f: data = f.read() for i in range(0, len(data), 2): if data[i:i + 2] == b'\x00\x00': error('symbols', 'Undefined xas99 symbol') # DORG special cases source = os.path.join(Dirs.sources, 'asdorg.asm') xas(source, '-a', '>2000', '-o', Files.output) ref = os.path.join(Dirs.sources, 'asdorg-ti.asm') xas(ref, '-a', '>2000', '-o', Files.reference) check_obj_code_eq(Files.output, Files.reference) # cleanup for i in range(4): os.remove(Files.outputff[i]) os.remove(Files.reference)
def runtest(): """check cross-generated output against native reference files""" # object code for infile, opts, reffile, cprfile in [ ("asdirs.asm", [], "ASDIRS-O", "ASDIRS-C"), ("asorgs.asm", [], "ASORGS-O", "ASORGS-C"), ("asopcs.asm", [], "ASOPCS-O", "ASOPCS-C"), ("asexprs.asm", [], "ASEXPRS-O", "ASEXPRS-C"), ("asbss.asm", [], "ASBSS-O", "ASBSS-C"), ("asregs.asm", ["-R"], "ASREGS-O", "ASREGS-C"), ("ashello.asm", ["-R"], "ASHELLO-O", "ASHELLO-C"), ("ascopy.asm", [], "ASCOPY-O", None), ("ascopyn.asm", [], "ASCOPYN-O", None), ("assize1.asm", [], "ASSIZE1-O", "ASSIZE1-C"), ("assize2.asm", [], "ASSIZE2-O", None), ("assize3.asm", [], "ASSIZE3-O", None), ("assize4.asm", [], "ASSIZE4-O", None), ("astisym.asm", [], "ASTISYM-O", "ASTISYM-C"), ("asimg1.asm", [], "ASIMG1-O", "ASIMG1-C"), ("asimg2.asm", [], "ASIMG2-O", None), ("asimg3.asm", [], "ASIMG3-OX", None), #("asreloc.asm", [], "ASRELOC-O", None), ("asxorg.asm", [], "ASXORG-O", None), ("ascart.asm", ["-R"], "ASCART-O", "ASCART-C") ]: source = os.path.join(Dirs.sources, infile) xdm(Disks.asmsrcs, "-e", reffile, "-o", Files.reference) xas(*[source] + opts + ["-o", Files.output]) checkObjCodeEq(Files.output, Files.reference) xas(*[source] + opts + ["--strict", "-o", Files.output]) checkObjCodeEq(Files.output, Files.reference) if cprfile: # compressed object code xas(*[source] + opts + ["-C", "-o", Files.output]) xdm(Disks.asmsrcs, "-e", cprfile, "-o", Files.reference) checkObjCodeEq(Files.output, Files.reference) # image files for infile, opts, reffile in [ ("ashello.asm", ["-R"], "ASHELLO-I"), ("astisym.asm", [], "ASTISYM-I"), ("asimg1.asm", [], "ASIMG1-I"), ("asimg2.asm", [], "ASIMG2-I") #("asimg3.asm", [], "ASIMG3-I") ]: source = os.path.join(Dirs.sources, infile) xas(*[source] + opts + ["-i", "-o", Files.output]) xdm(Disks.asmsrcs, "-e", reffile, "-o", Files.reference) checkImageFilesEq(Files.output, Files.reference) for infile, reffiles in [ ("aslimg.asm", ["ASLIMG-I", "ASLIMG-J", "ASLIMG-K"]), ("assimg.asm", ["ASSIMG-I", "ASSIMG-J", "ASSIMG-K", "ASSIMG-L"]), ("asreloc.asm", ["ASRELOC-I"]) ]: source = os.path.join(Dirs.sources, infile) xas(source, "-R", "-i", "-o", Files.output) for i, reffile in enumerate(reffiles): xdm(Disks.asmimgs, "-e", reffile, "-o", Files.reference) checkFilesEq("Image file", Files.outputff[i], Files.reference, fmt="P") # cleanup for i in xrange(4): os.remove(Files.outputff[i]) os.remove(Files.reference)
def runtest(): """check xdt99 extensions""" # xdt99 extensions source = os.path.join(Dirs.sources, "asxext.asm") xas(source, "-R", "-o", Files.output) xdm(Disks.asmsrcs, "-e", "ASXEXT0-O", "-o", Files.reference) checkObjCodeEq(Files.output, Files.reference) xas(source, "-R", "-D", "sym2", "-o", Files.output) xdm(Disks.asmsrcs, "-e", "ASXEXT1-O", "-o", Files.reference) checkObjCodeEq(Files.output, Files.reference) xas(source, "-R", "-D", "sym2=2", "sym3=2", "-o", Files.output) xdm(Disks.asmsrcs, "-e", "ASXEXT2-O", "-o", Files.reference) checkObjCodeEq(Files.output, Files.reference) xas(source, "-R", "-D", "sym2=2,sym3=2", "-o", Files.output) xdm(Disks.asmsrcs, "-e", "ASXEXT2-O", "-o", Files.reference) checkObjCodeEq(Files.output, Files.reference) # some CLI options source = os.path.join(Dirs.sources, "ashello.asm") xas(source, "--embed", "-R", "-o", Files.output) # misc new features for infile, reffile in [("asxnew.asm", "ASXNEW-O"), ("asmacs.asm", "ASMACS-O")]: source = os.path.join(Dirs.sources, infile) xas(source, "-o", Files.output) xdm(Disks.asmsrcs, "-e", reffile, "-o", Files.reference) checkObjCodeEq(Files.output, Files.reference) # SAVE directive source = os.path.join(Dirs.sources, "asxsave.asm") xas(source, "-b", "--base", "0xb000", "-o", Files.output) save1s = [Files.output + "_" + ext for ext in ["b000", "b020", "b030"]] checkConcatEq(save1s, os.path.join(Dirs.refs, "save1")) checkNoFiles([Files.output + "_b080"]) # bank switching source = os.path.join(Dirs.sources, "asxbank1.asm") xas(source, "-b", "-o", Files.output) save2s = [ Files.output + "_" + ext for ext in ["0000", "6000_b0", "6000_b1", "6100_b0", "6200_b1", "6200_b2"] ] checkConcatEq(save2s, os.path.join(Dirs.refs, "save2")) checkNoFiles([ Files.output + "_" + ext for ext in ["0000_b0", "6000", "6100_b1", "6200_b0"] ]) source = os.path.join(Dirs.sources, "asxbank2.asm") xas(source, "-b", "-o", Files.output) save3s = [ Files.output + "_" + ext for ext in ["c000", "c000_b0", "c000_b1", "d000_b0", "e000_b1"] ] checkConcatEq(save3s, os.path.join(Dirs.refs, "save3")) checkNoFiles([ Files.output + "_" + ext for ext in ["d000", "d000_b1", "e000", "e000_b0"] ]) source = os.path.join(Dirs.sources, "asxsegm.asm") xas(source, "-b", "-o", Files.output) checkFileSizes([ (Files.output + "_" + ext, size) for ext, size in [("0000", 20), ("b000_b1", 14), ("b010_b1", 2), ("b012_b2", 6)] ]) # cleanup os.remove(Files.output) os.remove(Files.reference) for fn in save1s + save2s + save3s: os.remove(fn)
def runtest(): """extract VAR record files generated by DMWRVAR.xb""" # setup shutil.copyfile(Disks.recsdis, Disks.work) # read full-size records for reclen in [16, 127, 128, 129, 254, 255]: xdm(Disks.work, "-e", "F" + str(reclen), "-o", Files.output) check_records_by_checksum(Files.output) for reclen in [16, 126, 127, 128, 254, 255]: xdm(Disks.work, "-e", "V" + str(reclen), "-o", Files.output) check_records_by_checksum(Files.output) # read partially filled records for reclen in [64]: xdm(Disks.work, "-e", "F" + str(reclen) + "V", "-o", Files.output) check_records_by_len(Files.output, fixed=reclen) for recid in [ "64V", "255V1", "255V2", "255V3", "255V4", "255V4", "255V5" ]: xdm(Disks.work, "-e", "V" + recid, "-o", Files.output) check_records_by_len(Files.output) # read special records xdm(Disks.work, "-e", "F10R", "-o", Files.output) check_files_eq("VAR Records", Files.output, os.path.join(Dirs.refs, "f10r.txt"), "DIS/FIX10") xdm(Disks.work, "-e", "V10R", "-o", Files.output) check_files_eq("VAR Records", Files.output, os.path.join(Dirs.refs, "v10r.txt"), "DIS/VAR10") # re-write extracted records and check for fn in [ "V1", "V16", "V126", "V127", "V128", "V254", "V64V", "V255V1", "V255V2", "V255V3", "V255V4", "V255V5", "V10R", "F10R", "F1", "F16", "F127", "F128", "F129", "F254", "F255", "F64V" ]: rectype = "DIS/VAR" if fn[0] == "V" else "DIS/FIX" reclen = re.search("\d+", fn).group(0) fmt = rectype + reclen xdm(Disks.work, "-e", fn, "-o", Files.reference) xdm(Disks.work, "-a", Files.reference, "-n", "COPY", "-f", fmt) xdm(Disks.work, "-e", "COPY", "-o", Files.output) check_files_eq("VAR Records", Files.output, Files.reference, fmt) # cleanup os.remove(Files.output) os.remove(Files.reference) os.remove(Disks.work)
def runtest(): """compare xbas99 generation to TI references""" for fn in ('KEYWORDS', 'STATMNTS', 'NUMBERS', 'COMMENTS', 'LOWRCASE', 'GIBBRISH'): # compare generated xbas99 listing with TI BASIC reference xdm(Disks.basic1, '-e', fn, '-o', Files.input) xdm(Disks.basic1, '-e', fn + '-L', '-o', Files.reference) xbas(Files.input, '-d', '-o', Files.output) check_listing_eq(Files.output, Files.reference) # ditto with MERGE format xdm(Disks.basic1, '-e', fn + '-M', '-o', Files.input) xbas(Files.input, '-d', '--merge', '-o', Files.output) check_listing_eq(Files.output, Files.reference) # compare generated xbas99 basic program with TI BASIC reference xdm(Disks.basic1, '-e', fn + '-L', '-o', Files.input) xdm(Disks.basic1, '-e', fn, '-o', Files.reference) xbas(Files.input, '-c', '-o', Files.output) check_binary_files_eq('Tokenization', Files.output, Files.reference) # ditto with non-canonically formatted original source rawlist = os.path.join(Dirs.basic, fn.lower() + '.txt') gen_listing(rawlist, Files.input) xbas(Files.input, '-c', '-o', Files.output) check_binary_files_eq('Tokenization', Files.output, Files.reference) # check using randomized listings for i in range(8): fn = 'RAND%02d' % i xdm(Disks.basic2, '-e', fn, '-o', Files.input) xdm(Disks.basic2, '-e', fn + '-L', '-o', Files.reference) # compare generated xbas99 listing with TI BASIC reference xbas(Files.input, '-d', '-o', Files.output) check_listing_eq(Files.output, Files.reference) # compare generated xbas99 basic program with TI BASIC reference xbas(Files.reference, '-c', '-j', ',2', '-o', Files.output) # some linos missing in listing check_binary_files_eq('Tokenization', Files.output, Files.input) # check long format path = os.path.join(Dirs.basic, 'sample-l.bin') xbas(path, '-d', '-o', Files.output) path = os.path.join(Dirs.basic, 'sample-n.bin') xbas(path, '-d', '-o', Files.reference) check_binary_files_eq('Long Format', Files.output, Files.reference) # check listing protection xdm(Disks.basic1, '-e', 'STATMNTS-L', '-o', Files.input) xbas(Files.input, '-c', '-j', '3,5', '--protect', '-o', Files.output) xbas(Files.input, '-c', '-j', '3,1', '-o', Files.reference) check_binary_files_eq('Protection', Files.output, Files.reference, mask=[(0, 2)]) # join source = os.path.join(Dirs.basic, 'basjoin.bas') xbas(source, '-c', '-j', '5,10', '-o', Files.input) xbas(Files.input, '-d', '-o', Files.output) check_line_numbers(Files.output, [100, 110, 120, 125]) # cleanup os.remove(Files.input) os.remove(Files.output) os.remove(Files.reference)
def runtest(): """extract INT record files generated by WRITEINT.bas""" # setup shutil.copyfile(Disks.recsint, Disks.work) # read full-size records for reclen in [2, 64, 127, 128, 254, 255]: xdm(Disks.work, "-e", "IF" + str(reclen), "-o", Files.output) checkRecordsByChecksum(Files.output, reclen, True) xdm(Disks.work, "-e", "IV" + str(reclen), "-o", Files.output) checkRecordsByChecksum(Files.output, reclen, False) # read partially filled records for fn in ["intfix32v", "intvar32v", "intfix128v", "intvar128v"]: xdm(Disks.work, "-e", fn.upper(), "-o", Files.output) ref = os.path.join(Dirs.refs, fn) checkFilesEq("INT Records", Files.output, ref, "P") # re-write extracted records and check for reclen in [2, 64, 127, 128, 254, 255]: xdm(Disks.work, "-e", "IF" + str(reclen), "-o", Files.reference) xdm(Disks.work, "-a", Files.reference, "-n", "CF" + str(reclen), "-f", "INT/FIX" + str(reclen)) xdm(Disks.work, "-e", "CF" + str(reclen), "-o", Files.output) checkFilesEq("Write INT", Files.output, Files.reference, "INT/FIX" + str(reclen)) xdm(Disks.work, "-e", "IV" + str(reclen), "-o", Files.reference) xdm(Disks.work, "-a", Files.reference, "-n", "CV" + str(reclen), "-f", "INT/VAR" + str(reclen)) xdm(Disks.work, "-e", "CV" + str(reclen), "-o", Files.output) checkFilesEq("Write INT", Files.output, Files.reference, "INT/VAR" + str(reclen)) # re-write partially filled records for fn, fmt in [ ("intfix32v", "IF32"), ("intvar32v", "IV32"), ("intfix128v", "IF128"), ("intvar128v", "IV128") ]: ref = os.path.join(Dirs.refs, fn) xdm(Disks.work, "-a", ref, "-n", "TEST", "-f", fmt) xdm(Disks.work, "-e", "TEST", "-o", Files.output) checkFilesEq("Write INT", Files.output, ref, "P") # cleanup os.remove(Files.output) os.remove(Files.reference) os.remove(Disks.work)