Changeset 2075

Timestamp:

May 8, 2012, 11:47:39 AM (7 years ago)

Author:

ksherdy

Message:

Boo.

Location:

trunk/symbol_table/test

Files:

• run_tests.py (added)
• st_test_file_generator.py (modified) (11 diffs)

trunk/symbol_table/test/st_test_file_generator.py

@@ -3 +3 @@
 import math
         
-# This script generates 3 files.
-#
-# 1. Output Test File 
-#
-#    L_O_U_L_O_U_L_O_U_Ag_Mg.test, where for each (L_O_U),
+# (i) Test Files
+#
+#   [L_O_U]+_Ag_Mg.test, where for each triple (L,O,U)
 #  
-#    * UNIFORM denotes that equal counts of symbols of each length L are generated
-#    * L denotes length
-#    * O denotes the total number of symbols of length L
-#    * U denotes the number of unique symbols of length L
+#    L - length
+#    O - total occurences of length L symbols
+#    U - unique occurences of length L symbols
 #
 #    and
@@ -19 +16 @@
 #    * Mg denotes the maximum absolute deviation gap distance, see Absolute Deviation
 #
-# 2. Meta Results File
-#
-#    L_O_U_L_O_U_L_O_U_Ag_Mg.meta
+# (ii) Test Meta Files
+#
+#    [L_O_U]+_Ag_Mg.meta
 # 
-#    This file contains start position, length and gap distance for each symbol contains in the generated test file, as 
-#    well as the average gap distance and the maximum gap distance.
-#       
+#    Contains test file meta data, i.e. start position,
+#    length and gap distance for each symbol contained
+#    in the generated test file.
 
 usage = "python testFileGenerator.py [L,O,U] [L,O,U] [L,O,U] ... AvgGap MaxGap"
 
-# parallel lists unique_symbols and unique_symbol_counts
-# list of unique symbols
+# parallel lists
 unique_symbols = [] 
-# list of counts of the number of occurrences for each unique symbol
 unique_symbol_counts = []
 
-# a list that contains symbol specification [[L,O,U], [L,O,U], [L,O,U], ...]
+# symbol specs [[L,O,U], [L,O,U], [L,O,U], ...]
 symbol_specs = []
 
 unique_sym_pos = []
 
-class SymbolFileGenerator:
-    testFileHandle = 0    
+################################################################################
+# Symbol Characters
+################################################################################
+def genLowerCaseCharactersList():
+    return ['a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z']
+
+def genUpperCaseCharactersList():
+    return ['A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z']
+
+def genDigitCharactersList():
+    return ['0','1','2','3','4','5','6','7','8','9']
+
+def genSpecialCharactersList():
+    return ['_',':','-','.']
+
+delim = ','
+char_pool = genDigitCharactersList() + genLowerCaseCharactersList() + genUpperCaseCharactersList() + genSpecialCharactersList() # XML-like characters
+
+class TestFileGenerator:
+    test_file = None
     def __init__(self,base_filename):    
-        self.testFileHandle = open(base_filename+".test", 'w')
-        
-    def appendUniqueSymbolAndGap(self, symbol_string, gap):    
-        self.testFileHandle.write(symbol_string + ','*gap)        
+        self.test_file = open(base_filename+".test", 'w')
+        
+    def appendUniqueSymbolAndGap(self, symbol_string, gap):
+        global delim
+        delims = delim*gap
+        self.test_file.write(symbol_string + delims)
         
     def close(self):
-        self.testFileHandle.close()
+        self.test_file.close()
       
 
 class SymbolLogger:
-    logFileHandle = 0
+    meta_file = 0
 
     def __init__(self,base_filename,unique_symbol_total,avg_gap, max_gap):
@@ -61 +76 @@
             unique_sym_pos.append([])
 
-        self.logFileHandle = open (base_filename+".meta", 'w')
-        self.logFileHandle.write("Average Gap Distance: " + str(avg_gap) + "\nMaximum Gap Distance: " + str(max_gap))
+        self.meta_file = open (base_filename+".meta", 'w')
+        self.meta_file.write("Average Gap Distance: " + str(avg_gap) + "\nMaximum Gap Distance: " + str(max_gap))
 
     def logUniqueSymbolPositions(self, index):
-        self.logFileHandle.write("Symbol \'" + unique_symbols[index] + "\' appeared at positions: \n")
-        self.logFileHandle.write(str(unique_sym_pos[index]) + "\n")
+        self.meta_file.write("Symbol \'" + unique_symbols[index] + "\' appeared at positions: \n")
+        self.meta_file.write(str(unique_sym_pos[index]) + "\n")
 
     def actualUniqueSymbolInfo(self,length,position,gap):
-        self.logFileHandle.write("Start: " + repr(position).rjust(10) + " | Length: " + repr(length).rjust(10) + " | Gap: " + repr(gap).rjust(10) + "\n")
+        self.meta_file.write("Start: " + repr(position).rjust(10) + " | Length: " + repr(length).rjust(10) + " | Gap: " + repr(gap).rjust(10) + "\n")
 
     def expectedUniqueSymbolsInfo(self, length, num_occurrences, num_unique_syms):
-        self.logFileHandle.write("Length " + str(length)
+        self.meta_file.write("Length " + str(length)
                        + "\nNumber of occurrences: " + str(num_occurrences)
                        + "\nNumber of unique symbols: " + str(num_unique_syms)
@@ -78 +93 @@
         for i in range (len(unique_symbols)):
             if len(unique_symbols[i]) == length:
-                self.logFileHandle.write ("\n\tSymbol \'" + unique_symbols[i] + "\'"
+                self.meta_file.write ("\n\tSymbol \'" + unique_symbols[i] + "\'"
                                    + "\n\tNumber of occurrences: " + str(unique_symbol_counts[i]))
-        self.logFileHandle.write("\n")
+        self.meta_file.write("\n")
 
     def appendAvgGapMaxGap(self,average_gap, max_gap):
         self.metadataMsg("")
-        self.logFileHandle.write("Average gap distance: " + str(average_gap) + "\nMaximum gap distance: " + str(max_gap))
+        self.meta_file.write("Average gap distance: " + str(average_gap) + "\nMaximum gap distance: " + str(max_gap))
 
     def metadataMsg(self,string):
-        self.logFileHandle.write("\n----------\n" + string +"\n")
+        self.meta_file.write("\n----------\n" + string +"\n")
             
     def close(self):
-        self.logFileHandle.close()
-
-def genLowerCaseCharactersList():
-    return ['a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z']
-
-def genUpperCaseCharactersList():
-    return ['A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z']
-
-def genDigitCharactersList():
-    return ['0','1','2','3','4','5','6','7','8','9']
-
-def genSpecialCharactersList():
-    return ['_',':','-','.']
+        self.meta_file.close()
 
 def genUniqueSymbol(length, num_unique_sym):
     new_symbols = []
     while (len(new_symbols) < num_unique_sym):
-        tempStr = ""
-        for j in range (length):
+        tempStr = ""
+        for j in range (length):
             sym_lst = genDigitCharactersList() + genLowerCaseCharactersList() + genUpperCaseCharactersList() + genSpecialCharactersList() # XML-like characters
             index = random.randint (0, len(sym_lst)-1)
-            tempStr += sym_lst[index]
-        #search for duplicates
-        if (new_symbols.count(tempStr) == 0):
-            new_symbols.append(tempStr)    
+            tempStr += sym_lst[index]
+        #search for duplicates
+        if (new_symbols.count(tempStr) == 0):
+            new_symbols.append(tempStr)
     unique_symbols.extend(new_symbols)
 
-# NOTE: This function assumes that num_occurences > num_unique_sym
+# WARNING: PRECONDITION: (num_occurences > num_unique_sym)
 def genDistributionUNIFORM(num_occurences, num_unique_sym):
     k = num_occurences/num_unique_sym
@@ -124 +127 @@
     unique_symbol_counts.append(k+(num_occurences % k))
     
-# NOTE: This function assumes that num_occurences > num_unique_sym
-def genDistributionRANDOM(num_occurences, num_unique_sym):
-    upperbound = num_occurences-num_unique_sym + 1
-    for i in range (num_unique_sym-1):
-        unique_symbol_counts.append(random.randint(1,upperbound))
-        num_occurences = num_occurences - unique_symbol_counts[len(unique_symbol_counts)-1]
-        upperbound = num_occurences - (num_unique_sym - i - 2)
-    unique_symbol_counts.append(num_occurences)
+# WARNING: PRECONDITION: (num_occurences > num_unique_sym)
+#def genDistributionRANDOM(num_occurences, num_unique_sym):
+#    upperbound = num_occurences-num_unique_sym + 1
+#    for i in range (num_unique_sym-1):
+#        unique_symbol_counts.append(random.randint(1,upperbound))
+#        num_occurences = num_occurences - unique_symbol_counts[len(unique_symbol_counts)-1]
+#        upperbound = num_occurences - (num_unique_sym - i - 2)
+#    unique_symbol_counts.append(num_occurences)
 
 def genSymbols():
@@ -181 +184 @@
                                     #print avg_gap - i
 
-
-
         gap = gaps.pop(random.randint(0, len(gaps) - 1))
         gap_total += gap
@@ -202 +203 @@
 
 def main(*arguments):
+
     num_args = len(arguments)
-    print num_args, arguments
     if num_args < 3:
         print usage
@@ -217 +218 @@
             sys.exit()
 
-        # parse unique symbol distributions
-        for i in range (num_args-2):
-            unique_symbol_dist_str = arguments[i]
-            lst = eval(unique_symbol_dist_str)
-            symbol_specs.append(lst)
+        # parse unique symbol distributions
+        for i in range (num_args-2):
+            unique_symbol_dist_str = arguments[i]
+            lst = eval(unique_symbol_dist_str)
+            symbol_specs.append(lst)
 
         print "Generating test file . . . "
@@ -237 +238 @@
          
         # construct logger instance 
-        symbol_file_generator = SymbolFileGenerator(base_filename)
+        symbol_file_generator = TestFileGenerator(base_filename)
         symbol_logger = SymbolLogger(base_filename, unique_symbol_total, avg_gap, max_gap)
                 
@@ -246 +247 @@
             # generate the unique symbols and the distribution of each of the symbols
             genUniqueSymbol(symbol_spec[0], symbol_spec[2])
-            genDistributionUNIFORM(symbol_spec[1], symbol_spec[2])
-            symbol_logger.expectedUniqueSymbolsInfo(symbol_spec[0], symbol_spec[1], symbol_spec[2])
+            genDistributionUNIFORM(symbol_spec[1], symbol_spec[2])
+            symbol_logger.expectedUniqueSymbolsInfo(symbol_spec[0], symbol_spec[1], symbol_spec[2])
             total_symbols += symbol_spec[1]
 
@@ -263 +264 @@
         symbol_logger.close()
 
-        print "Done generating test file"
+        print "Done generating test file."
 
         # reset shared variables