From f4c12fce1ee58e670f9c3fce46c40296ba9ee8a2 Mon Sep 17 00:00:00 2001 From: Ian Hodson Date: Wed, 30 May 2012 21:27:06 +0100 Subject: Add openfst to external, as used by GoogleTTS Moved from GoogleTTS Change-Id: I6bc6bdadaa53bd0f810b88443339f6d899502cc8 --- src/test/fst_test.cc | 228 +++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 228 insertions(+) create mode 100644 src/test/fst_test.cc (limited to 'src/test/fst_test.cc') diff --git a/src/test/fst_test.cc b/src/test/fst_test.cc new file mode 100644 index 0000000..7d8d600 --- /dev/null +++ b/src/test/fst_test.cc @@ -0,0 +1,228 @@ +// fst_test.cc + +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +// Copyright 2005-2010 Google, Inc. +// Author: riley@google.com (Michael Riley) +// +// \file +// Regression test for FST classes. + +#include "./fst_test.h" + +#include +#include +#include +#include + + +namespace fst { + +// A user-defined arc type. +struct CustomArc { + typedef short Label; + typedef ProductWeight Weight; + typedef int64 StateId; + + CustomArc(Label i, Label o, Weight w, StateId s) : + ilabel(i), olabel(o), weight(w), nextstate(s) {} + CustomArc() {} + + static const string &Type() { // Arc type name + static const string type = "my"; + return type; + } + + Label ilabel; // Transition input label + Label olabel; // Transition output label + Weight weight; // Transition weight + StateId nextstate; // Transition destination state +}; + + +// A user-defined compactor for test FST. +template +class CustomCompactor { + public: + typedef A Arc; + typedef typename A::Label Label; + typedef typename A::StateId StateId; + typedef typename A::Weight Weight; + typedef pair Element; + + Element Compact(StateId s, const A &arc) const { + return make_pair(arc.ilabel, arc.weight); + } + + Arc Expand(StateId s, const Element &p, uint32 f = kArcValueFlags) const { + return p.first == kNoLabel ? + Arc(kNoLabel, kNoLabel, p.second, kNoStateId) : + Arc(p.first, 0, p.second, s); + } + + ssize_t Size() const { return -1;} + + uint64 Properties() const { return 0ULL;} + + bool Compatible(const Fst &fst) const { + return true; + } + + static const string &Type() { + static const string type = "my"; + return type; + } + + bool Write(ostream &strm) const { return true; } + + static CustomCompactor *Read(istream &strm) { + return new CustomCompactor; + } +}; + + +REGISTER_FST(VectorFst, CustomArc); +REGISTER_FST(ConstFst, CustomArc); +static fst::FstRegisterer< + CompactFst > > +CompactFst_StdArc_CustomCompactor_registerer; +static fst::FstRegisterer< + CompactFst > > +CompactFst_CustomArc_CustomCompactor_registerer; +static fst::FstRegisterer > +ConstFst_StdArc_uint16_registerer; +static fst::FstRegisterer< + CompactFst, uint16> > +CompactFst_StdArc_CustomCompactor_uint16_registerer; + +} // namespace fst + + +using fst::FstTester; +using fst::VectorFst; +using fst::ConstFst; +using fst::MatcherFst; +using fst::CompactFst; +using fst::Fst; +using fst::StdArc; +using fst::CustomArc; +using fst::CustomCompactor; +using fst::StdArcLookAheadFst; +using fst::EditFst; + +int main(int argc, char **argv) { + FLAGS_fst_verify_properties = true; + std::set_new_handler(FailedNewHandler); + SetFlags(argv[0], &argc, &argv, true); + + // VectorFst tests + { + FstTester< VectorFst > std_vector_tester; + std_vector_tester.TestBase(); + std_vector_tester.TestExpanded(); + std_vector_tester.TestAssign(); + std_vector_tester.TestCopy(); + std_vector_tester.TestIO(); + std_vector_tester.TestMutable(); + } + + // ConstFst tests + { + FstTester< ConstFst > std_const_tester; + std_const_tester.TestBase(); + std_const_tester.TestExpanded(); + std_const_tester.TestCopy(); + std_const_tester.TestIO(); + } + + // CompactFst > + { + FstTester< CompactFst > > + std_compact_tester; + std_compact_tester.TestBase(); + std_compact_tester.TestExpanded(); + std_compact_tester.TestCopy(); + std_compact_tester.TestIO(); + } + + // VectorFst tests + { + FstTester< VectorFst > std_vector_tester; + std_vector_tester.TestBase(); + std_vector_tester.TestExpanded(); + std_vector_tester.TestAssign(); + std_vector_tester.TestCopy(); + std_vector_tester.TestIO(); + std_vector_tester.TestMutable(); + } + + // ConstFst tests + { + FstTester< ConstFst > std_const_tester; + std_const_tester.TestBase(); + std_const_tester.TestExpanded(); + std_const_tester.TestCopy(); + std_const_tester.TestIO(); + } + + // CompactFst > + { + FstTester< CompactFst > > + std_compact_tester; + std_compact_tester.TestBase(); + std_compact_tester.TestExpanded(); + std_compact_tester.TestCopy(); + std_compact_tester.TestIO(); + } + + // ConstFst tests + { + FstTester< ConstFst > std_const_tester; + std_const_tester.TestBase(); + std_const_tester.TestExpanded(); + std_const_tester.TestCopy(); + std_const_tester.TestIO(); + } + + // CompactFst, uint16> + { + FstTester< CompactFst, uint16> > + std_compact_tester; + std_compact_tester.TestBase(); + std_compact_tester.TestExpanded(); + std_compact_tester.TestCopy(); + std_compact_tester.TestIO(); + } + + // FstTester + { + FstTester std_matcher_tester; + std_matcher_tester.TestBase(); + std_matcher_tester.TestExpanded(); + std_matcher_tester.TestCopy(); + } + + // EditFst tests + { + FstTester< EditFst > std_edit_tester; + std_edit_tester.TestBase(); + std_edit_tester.TestExpanded(); + std_edit_tester.TestAssign(); + std_edit_tester.TestCopy(); + std_edit_tester.TestMutable(); + } + + cout << "PASS" << endl; + + return 0; +} -- cgit v1.2.3