origen_std_lib 0.7.0 → 0.8.0

data/stdlib/v93k/origen/origen/utils/version.hpp

@@ -0,0 +1,64 @@
+#ifndef ORIGEN_UTILS_VERSION_INCLUDED
+#define ORIGEN_UTILS_VERSION_INCLUDED
+
+// GCC adds these macros by default, which clobbers our functions
+// of the same name
+#if (defined(__GNUC__) || defined(__GNUG__)) && !(defined(__clang__) || defined(__INTEL_COMPILER))
+// Not exactly sure the version that this becomes a problem, but for
+// now this fixes the build on the V93K production system
+#if (__GNUC_MINOR__ > 1)
+#ifdef major
+#undef major
+#endif
+#ifdef minor
+#undef minor
+#endif
+#endif
+#endif
+
+#include <string>
+#include <vector>
+using namespace std;
+
+namespace Origen {
+namespace Utils {
+
+// The version class provides an easy way to create conditions based
+// on the version of a library.
+//
+// An instance of the class is returned by Origen.version and which
+// reflects the current version of the Origen library.
+//
+//   if (Origen.version < "1.1.0") {
+//     // Do something
+//   }
+//
+//   if (Origen.version.major() == 2) {
+//     // Do something
+//   }
+class Version {
+
+private:
+    vector<int> parse(string ver);
+    int _major;
+    int _minor;
+    int _tiny;
+
+public:
+    int major();
+    int minor();
+    int tiny();
+    Version(string ver);
+    bool operator==(string rhs);
+    bool operator!=(string rhs);
+    bool operator<(string rhs);
+    bool operator<=(string rhs);
+    bool operator>(string rhs);
+    bool operator>=(string rhs);
+    string str();
+};
+
+}
+}
+
+#endif

data/stdlib/v93k/origen/test_methods/ApplyBin.cpp

@@ -0,0 +1,41 @@
+#include "testmethod.hpp"
+
+//for test method API interfaces
+#include "mapi.hpp"
+using namespace std;
+#include "origen.hpp"
+
+/**
+ * Test method class.
+ *
+ * For each testsuite using this test method, one object of this
+ * class is created.
+ */
+class ApplyBin: public testmethod::TestMethod {
+
+protected:
+  /**
+   *Initialize the parameter interface to the testflow.
+   *This method is called just once after a testsuite is created.
+   */
+  virtual void initialize()
+  {
+    //Add your initialization code here
+    //Note: Test Method API should not be used in this method!
+  }
+
+  /**
+   *This test is invoked per site.
+   */
+  virtual void run()
+  {
+	  if (Origen::site().bin() || Origen::site().softbin()) {
+		  stringstream softbin;
+		  softbin << Origen::site().softbin();
+		  SET_MULTIBIN(softbin.str(), Origen::site().bin());
+		  TESTSET().judgeAndLog_FunctionalTest(false);
+	  }
+  }
+
+};
+REGISTER_TESTMETHOD("ApplyBin", ApplyBin);

data/stdlib/v93k/origen/test_methods/DCMeasurement.cpp

@@ -0,0 +1,127 @@
+#include "testmethod.hpp"
+
+//for test method API interfaces
+#include "mapi.hpp"
+using namespace std;
+#include "origen/test_method/dc_measurement.hpp"
+
+/**
+ * Test method class.
+ *
+ * For each testsuite using this test method, one object of this
+ * class is created.
+ */
+class DCMeasurement: public testmethod::TestMethod, public Origen::TestMethod::DCMeasurement {
+protected:
+  int  mApplyShutdown;
+  string  mShutdownPattern;
+  string  mMeasure;
+  double  mSettlingTime;
+  string  mPin;
+  double  mForceValue;
+  double  mIRange;
+  int mCheckShutdown;
+  int mBadc;
+
+protected:
+  /**
+   *Initialize the parameter interface to the testflow.
+   *This method is called just once after a testsuite is created.
+   */
+  virtual void initialize()
+  {
+    //Add your initialization code here
+    //Note: Test Method API should not be used in this method!
+    addParameter("applyShutdown",
+                 "int",
+                 &mApplyShutdown,
+                 testmethod::TM_PARAMETER_INPUT)
+      .setDefault("1")
+      .setComment("Apply a shutdown pattern after taking the measurement");
+    addParameter("shutdownPattern",
+                 "string",
+                 &mShutdownPattern,
+                 testmethod::TM_PARAMETER_INPUT)
+      .setComment("The name of the shutdown pattern, by default it will be the main pattern name appended with '_part1'");
+    addParameter("checkShutdown",
+                 "int",
+                 &mCheckShutdown,
+                 testmethod::TM_PARAMETER_INPUT)
+      .setDefault("1")
+      .setComment("Check that the shutdown pattern passed (and fail if not)");
+    addParameter("measure",
+                 "string",
+                 &mMeasure,
+                 testmethod::TM_PARAMETER_INPUT)
+      .setDefault("VOLT")
+      .setComment("Measure 'CURR' or 'VOLT' (the default)");
+    addParameter("settlingTime",
+                 "double",
+                 &mSettlingTime,
+                 testmethod::TM_PARAMETER_INPUT)
+      .setDefault("0")
+      .setComment("Time to wait between running the pattern and taking the measurement, expressed in ms");
+    addParameter("pin",
+                 "PinString",
+                 &mPin,
+                 testmethod::TM_PARAMETER_INPUT)
+      .setComment("Pin to be measured");
+    addParameter("forceValue",
+                 "double",
+                 &mForceValue,
+                 testmethod::TM_PARAMETER_INPUT)
+      .setDefault("0")
+      .setComment("Value to be forced on the pin during the measurement");
+    addParameter("iRange",
+                 "double",
+                 &mIRange,
+                 testmethod::TM_PARAMETER_INPUT)
+      .setDefault("0")
+      .setComment("The current range to apply to the measurement (in A), will be calculated if not supplied (set to 0)");
+    addParameter("badc",
+                 "int",
+                 &mBadc,
+                 testmethod::TM_PARAMETER_INPUT)
+      .setDefault("0")
+      .setComment("Perform the measurement using the Board ADC (rather than the PPMU)");
+    addLimit("Functional");
+  }
+
+  /**
+   *This test is invoked per site.
+   */
+  virtual void run()
+  {
+    origen.applyShutdown(mApplyShutdown)
+          .forceValue(mForceValue)
+          .shutdownPattern(mShutdownPattern)
+          .checkShutdown(mCheckShutdown)
+          .measure(mMeasure)
+          .settlingTime(mSettlingTime)
+          .pin(mPin)
+          .iRange(mIRange)
+          .badc(mBadc)
+          .execute();
+  }
+
+  /**
+   *This function will be invoked once the specified parameter's value is changed.
+   *@param parameterIdentifier
+   */
+  virtual void postParameterChange(const string& parameterIdentifier)
+  {
+    //Add your code
+    //Note: Test Method API should not be used in this method!
+    return;
+  }
+
+  /**
+   *This function will be invoked once the Select Test Method Dialog is opened.
+   */
+  virtual const string getComment() const 
+  {
+    string comment = " please add your comment for this method.";
+    return comment;
+  }
+};
+REGISTER_TESTMETHOD("DCMeasurement", DCMeasurement);

data/stdlib/v93k/origen/test_methods/FrequencyMeasurement.cpp

@@ -0,0 +1,91 @@
+#include "testmethod.hpp"
+
+//for test method API interfaces
+#include "mapi.hpp"
+using namespace std;
+#include "../origen/test_method/frequency_measurement.hpp"
+
+/**
+ * Test method class.
+ *
+ * For each testsuite using this test method, one object of this
+ * class is created.
+ */
+class FrequencyMeasurement: public testmethod::TestMethod,
+                            public Origen::TestMethod::FrequencyMeasurement {
+
+protected:                                 
+  int    mPeriodBased;
+  string mPin;
+  int    mSamples;
+  int    mPeriodInNs;
+
+protected:
+  /**
+   *Initialize the parameter interface to the testflow.
+   *This method is called just once after a testsuite is created.
+   */
+  virtual void initialize()
+  {
+    addParameter("periodBased",
+                 "int",
+                 &mPeriodBased,
+                 testmethod::TM_PARAMETER_INPUT)
+      .setDefault("0")
+      .setComment("Set to 1 if the limits are expressed as a period instead of a frequency (the default)");
+    addParameter("pin",
+                 "PinString",
+                 &mPin,
+                 testmethod::TM_PARAMETER_INPUT)
+      .setComment("Pin to be measured");
+    addParameter("samples",
+                 "int",
+                 &mSamples,
+                 testmethod::TM_PARAMETER_INPUT)
+      .setDefault("2000")
+      .setComment("The number of captures made by the pattern, defaults to 2000");
+    addParameter("periodInNs",
+                 "int",
+                 &mPeriodInNs,
+                 testmethod::TM_PARAMETER_INPUT)
+      .setComment("The period of the capture vectors");
+
+
+    //Add your initialization code here
+    //Note: Test Method API should not be used in this method!
+    addLimit("Functional");
+  }
+
+  /**
+   *This test is invoked per site.
+   */
+  virtual void run()
+  {
+      origen.periodBased(mPeriodBased)
+            .pin(mPin)
+            .samples(mSamples)
+            .periodInNs(mPeriodInNs)
+            .execute();
+  }
+
+  /**
+   *This function will be invoked once the specified parameter's value is changed.
+   *@param parameterIdentifier
+   */
+  virtual void postParameterChange(const string& parameterIdentifier)
+  {
+    //Add your code
+    //Note: Test Method API should not be used in this method!
+    return;
+  }
+
+  /**
+   *This function will be invoked once the Select Test Method Dialog is opened.
+   */
+  virtual const string getComment() const 
+  {
+    string comment = " please add your comment for this method.";
+    return comment;
+  }
+};
+REGISTER_TESTMETHOD("FrequencyMeasurement", FrequencyMeasurement);

data/stdlib/v93k/origen/test_methods/FunctionalTest.cpp

@@ -0,0 +1,92 @@
+#include "testmethod.hpp"
+
+//for test method API interfaces
+#include "mapi.hpp"
+#include "rdi.hpp"
+using namespace std;
+#include "origen/test_method/functional_test.hpp"
+
+/**
+ * Test method class.
+ *
+ * For each testsuite using this test method, one object of this
+ * class is created.
+ */
+class FunctionalTest: public testmethod::TestMethod,
+    public Origen::TestMethod::FunctionalTest {
+
+protected:
+    /**
+     *Initialize the parameter interface to the testflow.
+     *This method is called just once after a testsuite is created.
+     */
+    virtual void initialize() {
+        //Add your initialization code here
+        //Note: Test Method API should not be used in this method!
+//    	addLimit("testlimit");
+    }
+
+    /**
+     *This test is invoked per site.
+     */
+    virtual void run() {
+        origen.execute();
+
+//    	string label = Primary.getLabel();
+//    	string testSuiteName;
+//    	GET_TESTSUITE_NAME(testSuiteName);
+//
+//    	RDI_INIT();
+//    	ON_FIRST_INVOCATION_BEGIN();
+//        RDI_BEGIN();
+//    	rdi.func(testSuiteName).label(label).execute();
+//
+////    	cout << testSuiteName << endl;
+////    	cout << label << endl;
+//    	RDI_END();
+//    	cout << "-----------------" << endl;
+//        ON_FIRST_INVOCATION_END();
+//
+//        int site = CURRENT_SITE_NUMBER();
+//        int res = rdi.id(testSuiteName).getPassFail();
+//       cout << CURRENT_SITE_NUMBER() << ":" << res << endl;
+//        Origen::logFunctionalTest(testSuiteName, site, res == 1, label);
+//    //    TESTSET().judgeAndLog_FunctionalTest(CURRENT_SITE_NUMBER()  !=  2);
+
+/*
+    	string name;
+    	GET_TESTSUITE_NAME(name);
+    	RDI_INIT();
+        ON_FIRST_INVOCATION_BEGIN();
+    		FUNCTIONAL_TEST();
+//			RDI_BEGIN();
+//				rdi.func(name).label(Primary.getLabel()).execute();
+//			RDI_END();
+        ON_FIRST_INVOCATION_END();
+
+    	cout << "Result is " << GET_FUNCTIONAL_RESULT("@") << endl;
+//    	cout << "Result is " << rdi.id(name).getPassFail() << endl;
+//    	TESTSET().cont(true).judgeAndLog_FunctionalTest();
+//    	TESTSET().cont(true).judgeAndLog_ParametricTest("@","testlimit",GET_FUNCTIONAL_RESULT("@"));
+*/
+    }
+
+    /**
+     *This function will be invoked once the specified parameter's value is changed.
+     *@param parameterIdentifier
+     */
+    virtual void postParameterChange(const string& parameterIdentifier) {
+        //Add your code
+        //Note: Test Method API should not be used in this method!
+        return;
+    }
+
+    /**
+     *This function will be invoked once the Select Test Method Dialog is opened.
+     */
+    virtual const string getComment() const {
+        string comment = " please add your comment for this method.";
+        return comment;
+    }
+};
+REGISTER_TESTMETHOD("FunctionalTest", FunctionalTest);

data/stdlib/v93k/origen/test_methods/RecordBin.cpp

@@ -0,0 +1,48 @@
+#include "testmethod.hpp"
+
+//for test method API interfaces
+#include "mapi.hpp"
+using namespace std;
+#include "origen.hpp"
+
+/**
+ * Test method class.
+ *
+ * For each testsuite using this test method, one object of this
+ * class is created.
+ */
+class RecordBin: public testmethod::TestMethod {
+protected:
+  int  mBin;
+  int  mSoftbin;
+
+protected:
+  /**
+   *Initialize the parameter interface to the testflow.
+   *This method is called just once after a testsuite is created.
+   */
+  virtual void initialize()
+  {
+    //Add your initialization code here
+    //Note: Test Method API should not be used in this method!
+    addParameter("bin",
+                 "int",
+                 &mBin,
+                 testmethod::TM_PARAMETER_INPUT);
+    addParameter("softbin",
+                 "int",
+                 &mSoftbin,
+                 testmethod::TM_PARAMETER_INPUT);
+  }
+
+  /**
+   *This test is invoked per site.
+   */
+  virtual void run()
+  {
+	  Origen::site().bin(mBin);
+	  Origen::site().softbin(mSoftbin);
+  }
+
+};
+REGISTER_TESTMETHOD("RecordBin", RecordBin);