C++ Reporter类代码示例

TEST(TestValidate, Simple)
{
    boost::shared_ptr<SimpleTest> n(new SimpleTest());

    {
        Reporter reporter;
        NodeReporter node_reporter(reporter, n);

        ASSERT_EQ(0UL, reporter.num_errors());
        ASSERT_EQ(0UL, reporter.num_warnings());

        n->pre_transform(node_reporter);
        EXPECT_EQ(1UL, reporter.num_errors());
        EXPECT_EQ(3UL, reporter.num_warnings());
        EXPECT_TRUE(n->pre_transform_called);
        EXPECT_FALSE(n->post_transform_called);
    }

    n->add_child(node_p(new Null()));

    {
        Reporter reporter;
        NodeReporter node_reporter(reporter, n);

        ASSERT_EQ(0UL, reporter.num_errors());
        ASSERT_EQ(0UL, reporter.num_warnings());

        n->pre_transform_called = false;
        n->post_transform(node_reporter);
        EXPECT_EQ(0UL, reporter.num_errors());
        EXPECT_EQ(3UL, reporter.num_warnings());
        EXPECT_FALSE(n->pre_transform_called);
        EXPECT_TRUE(n->post_transform_called);
    }
}

void CardDriverActivity::printOn(Reporter& report) const{
	report.tagValuePair(tr("oldestRecord"), oldestRecord);
	report.tagValuePair(tr("newestRecord"), newestRecord);
	report.writeArray(cardActivityDailyRecords, tr("cardActivityDailyRecords"));
	if(cardActivityDailyRecords.numberOfBlocks() > 0){
		QString tablehead = QString("<table><tr><th></th><th>%1</th><th>%2</th><th>%3</th><th>%4</th></tr>").arg(tr("Driving"), tr("Working"), tr("Rest"), tr("Available"));
		activityVector durationsMonth;
		int currentMonth = cardActivityDailyRecords[0].activityRecordDate.date().month();
		QString table = QString("<ul><li>%1:").arg(tr("Timesheet for %1").arg(QDate::longMonthName(currentMonth))) + tablehead;
		for(int j = 0; j < cardActivityDailyRecords.numberOfBlocks(); ++j){
			if(cardActivityDailyRecords[j].activityRecordDate.date().month() != currentMonth){
				currentMonth = cardActivityDailyRecords[j].activityRecordDate.date().month();
				table += QString("<tr><th>%1</th><th>%2</th><th>%3</th><th>%4</th><th>%5</th></tr>").arg(tr("Summary"), ActivityChangeInfo::formatClock(durationsMonth[ActivityChangeInfo::DRIVING]), ActivityChangeInfo::formatClock(durationsMonth[ActivityChangeInfo::WORK]), ActivityChangeInfo::formatClock(durationsMonth[ActivityChangeInfo::REST] + durationsMonth[ActivityChangeInfo::SHORTREST]), ActivityChangeInfo::formatClock(durationsMonth[ActivityChangeInfo::AVAILABLE]));

				durationsMonth = activityVector();
				table += QString("</table></li><li>%1:").arg(tr("Timesheet for %1").arg(QDate::longMonthName(currentMonth))) + tablehead;
			}
			activityVector durations;
			for(int k = 0; k < cardActivityDailyRecords[j].activityChangeInfos.numberOfBlocks(); ++k){
				durations[cardActivityDailyRecords[j].activityChangeInfos[k].activity] += cardActivityDailyRecords[j].activityChangeInfos[k].duration;
			}
			table += QString("<tr><td>%1</td><td>%2</td><td>%3</td><td>%4</td><td>%5</td></tr>").arg( cardActivityDailyRecords[j].activityRecordDate.toString(), ActivityChangeInfo::formatClock(durations[ActivityChangeInfo::DRIVING]), ActivityChangeInfo::formatClock(durations[ActivityChangeInfo::WORK]), ActivityChangeInfo::formatClock(durations[ActivityChangeInfo::REST] + durations[ActivityChangeInfo::SHORTREST]), ActivityChangeInfo::formatClock(durations[ActivityChangeInfo::AVAILABLE]));
			durationsMonth += durations;
		}
		table += QString("<tr><th>%1</th><th>%2</th><th>%3</th><th>%4</th><th>%4</th></tr>").arg(tr("Summary"), ActivityChangeInfo::formatClock(durationsMonth[ActivityChangeInfo::DRIVING]), ActivityChangeInfo::formatClock(durationsMonth[ActivityChangeInfo::WORK]), ActivityChangeInfo::formatClock(durationsMonth[ActivityChangeInfo::REST] + durationsMonth[ActivityChangeInfo::SHORTREST]), ActivityChangeInfo::formatClock(durationsMonth[ActivityChangeInfo::AVAILABLE]));

		table += "</table></li></ul>";
		report.tagValuePair(tr("Timesheet"), table);
	}
}

int main(int argc, char * argv[])
{
    if (argc < 2)
    {
        printf("Usage at_command <command> ...\n");
        return -1;
    }

    QApplication app(argc, argv);

    ModemMap mm;
    SerialPort sp(mm.signalChannel().toAscii());
    Reporter * reporter = 0;
    if (mm.provider() == "ZTE")
    {
        reporter = new ZTEReport(mm);
    }
    else
    {
        reporter = new HuaWeiReport(mm);
    }
    QByteArray data;
    data.append(argv[1]);
    if (!data.endsWith('\r'))
    {
        data.append('\r');
    }
    reporter->sendCommand(sp, data, 5000);
    qDebug("Result:");
    qDebug() << data;

    return 0;
}

void Forth_test_stdwords(bool verbose) {
    ForthEnv env;
    Reporter reporter;

    for (size_t i = 0; i < SK_ARRAY_COUNT(gRecs); i++) {
        ForthEngine engine(NULL);
        
        ForthWord* word = env.findWord(gRecs[i].fName);
        if (NULL == word) {
            SkString str;
            str.printf("--- can't find stdword %d", gRecs[i].fName);
            reporter.reportFailure(str.c_str());
        } else {
            if (verbose) {
                SkDebugf("--- testing %s %p\n", gRecs[i].fName, word);
            }
            gRecs[i].fProc(word, &engine, &reporter);
        }
    }
    
    if (0 == reporter.fFailureCount) {
        SkDebugf("--- success!\n");
    } else {
        SkDebugf("--- %d failures\n", reporter.fFailureCount);
    }
}

/**
Function to get an executable's Offset location.
1. Traverse through all the image entries available in the iImgVsExeStatus container.
2. Get the executable Offset.

@internalComponent
@released

@param aExeName - Executable's name.

@return - returns 0 upon failure to find the Executable.
        - otherwise returns the Offset.
*/
const unsigned int SidChecker::GetExecutableOffset(const String& aExeName)
{
    Reporter* reporter = Reporter::Instance(iCmdLine->ReportFlag());
    ImgVsExeStatus& aImgVsExeStatus = reporter->GetContainerReference();

    ImgVsExeStatus::iterator imgBegin = aImgVsExeStatus.begin();
    ImgVsExeStatus::iterator imgEnd = aImgVsExeStatus.end();

    ExeVsMetaData::iterator exeBegin;
    ExeVsMetaData::iterator exeEnd;

    while(imgBegin != imgEnd)
    {
        ExeVsMetaData& exeVsMetaData = imgBegin->second;
        exeBegin = exeVsMetaData.begin();
        exeEnd = exeVsMetaData.end();

        while(exeBegin != exeEnd)
        {
            if(aExeName == (exeBegin->second).iExeName)
            {
                return (exeBegin->second).iIdData->iFileOffset;
            }
            ++exeBegin;
        }
        ++imgBegin;
    }
    return 0;
}

void EncryptedCertificate::printOn(Reporter& report) const {
	if(decryptedCertificate){
		decryptedCertificate->printOn(report);
		report.writeBlock(certificateAuthorityReference, tr("Certificate verified from:"));
	} else {
		report.writeBlock(certificateAuthorityReference, tr("Unverified certificate, needs verification from:"));
	}
}

static void ProgressCallback(Object *object, const EventObject &event, void *clientdata)
{
    ProcessObject *process = dynamic_cast<ProcessObject *>(object);
    Reporter *reporter = reinterpret_cast<Reporter *>(clientdata);
    if (process && reporter) {
        float progress = process->GetProgress();
        reporter->report(int(progress * 100.f));
    }
}

void check_elapsed(bool check=true)
{
  Reporter sw;
  ex::sleep_for<typename Reporter::clock>(milliseconds(100));
  typename Reporter::duration d=sw.elapsed();
  std::cout << d << std::endl;
  if (check)
    BOOST_TEST(d >= milliseconds(100));
}

void Launcher::ReportPhase(Reporter& reporter, const PhaseCore& phase, const std::string& name) const
{
    reporter.ReportPhaseHeader();
    reporter.ReportPhase(phase, phase.metrics());
    reporter.ReportPhaseFooter();
    for (auto& child : phase._child)
    {
        std::string child_name = name + "." + child->name();
        ReportPhase(reporter, *child, child_name);
    }
}

		/**
		 * @brief Main function 
		 */
		static void main()
		{
			string ip;

			cout << "----------------------------------------------------------------------------" << endl;
			cout << "	REPOTER" << endl;
			cout << "----------------------------------------------------------------------------" << endl;
			cout << endl;

			Reporter reporter;
			reporter.open();
		};

    void run(Reporter& reporter)
    {
        reporter.run();

        for (auto it = suites_.begin(); it != suites_.end(); ++it)
        {
            reporter.runTestSuite(it->second->number(), it->second->name());
            it->second->runTests(reporter);
            reporter.finishTestSuite();
        }

        reporter.finish();
    }

  /**
   * \brief Reduce down the values from another aggregate UDF instance, and copy in to this aggregate instance
   */
  void reduce(const AggregateUDF* otherAgg, Reporter& reporter) {
    try {
      // loop through other's values and add to our equivalent value (if exists)
      // if doesn't exist in our values, add to our values
      const GroupAndAggregateUDF* other = (const GroupAndAggregateUDF*)otherAgg;
      for(auto ivi=other->interimValues.begin(); ivi!=other->interimValues.end(); ++ivi) {
        std::string groupBy(ivi->first);

        auto it = interimValues.find(groupBy);
        if (it == interimValues.end()) {
          // new
          IInterimResult* newInterim = resultTypeRef();
          newInterim->groupByValue = groupBy;
          newInterim->merge(ivi->second);
          interimValues.insert(std::pair<std::string,IInterimResult*>(groupBy,newInterim));
        } else {
          IInterimResult* interim = interimValues.at(groupBy);
          // merge
          interim->merge(ivi->second);
        }
      } // end for
    } catch (std::exception& ex) {
      reporter.error(("Exception in reduce(): " + std::string(ex.what())).c_str());
    }
  } // end reduce

  /**
   * \brief Get the values we need for the aggregate and cache them
   *
   * Assume the first column (index 0) is the group by field (with LOW cardinality)
   */
  void map(TupleIterator& values, Reporter& reporter) {
    try {
      for (; !values.done(); values.next()) {
        std::string groupBy;
        String tempString;
        values.value(0,tempString);
        groupBy = std::string(tempString);

        auto it = interimValues.find(groupBy);
        if (it == interimValues.end()) {
          // new
          IInterimResult* newInterim = resultTypeRef();
          newInterim->groupByValue = groupBy;
          newInterim->add(values);
          interimValues.insert(std::pair<std::string,IInterimResult*>(groupBy,newInterim));
        } else {
          IInterimResult* interim = interimValues.at(groupBy);
          // merge
          interim->add(values);
        }
      }
    } catch (std::exception& ex) {
      reporter.error(("Exception in map(): " + std::string(ex.what())).c_str());
    }
  }

 /**
  * \brief Return the final result from the remaining aggregate UDF instance
  */
 void finish(OutputSequence& os, Reporter& reporter) {
   try {
     // Take Interim Values and merge results
     for (auto ivi = interimValues.begin();ivi != interimValues.end();++ivi) {
       ivi->second->writeToMap(os);
     }
   } catch (std::exception& ex) {
     reporter.error(("Exception in finish(): " + std::string(ex.what())).c_str());
   }
 }

  /**
   * \brief Encode to XDQP stream
   */
  void encode(Encoder& e, Reporter& reporter) {
    try {
      // TODO consider gzip compression at this top level, and using a std::ostringstream to collate values (optional setting at aggregate level)

      // no need to encode resultTypeRef as that's handled in the start() or clone() function
      // do need to encode count though
      e.encode((int)interimValues.size());
      for (auto ivi = interimValues.begin();ivi != interimValues.end();++ivi) {
        ivi->second->encode(e,reporter);
      }
    } catch (std::exception& ex) {
      reporter.error(("Exception in encode(): " + std::string(ex.what())).c_str());
    }
  }