diff --git a/BUILD.gn b/BUILD.gn
index 2a8bc19a8ca8639ae62c11dc24fea6cbe8fb58bb..479351f76b44c8b7ef2dd8263cab403b5ea26e11 100644
--- a/BUILD.gn
+++ b/BUILD.gn
@@ -30,6 +30,12 @@ group("mplfe") {
   ]
 }
 
+group("mplfeUT") {
+  deps = [
+    "${MPLFE_ROOT}/test:mplfeUT",
+  ]
+}
+
 group("ast2mpl") {
   deps = []
   if (IS_AST2MPL_EXISTS == "1") {
diff --git a/Makefile b/Makefile
index dd9312517fcc8f060d60a0b2a53bf372665eb7e4..e34a8a8fc8142d707b6b06ce23395cc85fee737e 100644
--- a/Makefile
+++ b/Makefile
@@ -55,6 +55,10 @@ ast2mpl:
 mplfe:
 	$(call build_gn, ${GN_OPTIONS}, mplfe)
 
+.PHONY: mplfeUT
+mplfeUT:
+	$(call build_gn, ${GN_OPTIONS} COV_CHECK=1, mplfeUT)
+
 .PHONY: install
 install: maple
 	$(shell mkdir -p $(MAPLE_ROOT)/output/ops/linker/; \
diff --git a/build/config/BUILDCONFIG.gn b/build/config/BUILDCONFIG.gn
index a587a85778bd0435729dab252051b7b9166184b5..e2cc8c3fbceee7a0a0595165f78077c93d0d482a 100644
--- a/build/config/BUILDCONFIG.gn
+++ b/build/config/BUILDCONFIG.gn
@@ -21,6 +21,7 @@ declare_args() {
   GN_BUILD_TYPE = ""
   HOST_ARCH = 64
   MIR_JAVA = 1
+  COV_CHECK = 0
 }
 
 # Define global args
diff --git a/build/envsetup.sh b/build/envsetup.sh
index 9536e0a809d798df4a4af65eddd47700d189c0ec..071ab644172e3ef051f75032ca37f9b4e91ba9e3 100644
--- a/build/envsetup.sh
+++ b/build/envsetup.sh
@@ -26,3 +26,5 @@ if [ -d ${MAPLE_ROOT}/src/ast2mpl ]; then
 else
   export IS_AST2MPL_EXISTS=0
 fi
+export GCOV_PREFIX=${MAPLE_ROOT}/report/gcda
+export GCOV_PREFIX_STRIP=7
diff --git a/src/bin/jbc2mpl b/src/bin/jbc2mpl
index a43b06066043118a424f99594593b8d23e5121ed..4bba43c9b7cbc1a3a3fe757b2cffd759af6c603a 100755
Binary files a/src/bin/jbc2mpl and b/src/bin/jbc2mpl differ
diff --git a/src/bin/maple b/src/bin/maple
index 1325a895ee47d3899e033741176b33dd703d7f49..c38af607d42b164ddd0c8f0d72ad6fc4ac2c3bc7 100755
Binary files a/src/bin/maple and b/src/bin/maple differ
diff --git a/src/deplibs/libmplphase.a b/src/deplibs/libmplphase.a
index 88b01e34d3aa2c7c117f32a89e3671e38d08f322..ee4d005f1d6293fb2bd02c21acb39b5c659a2507 100644
Binary files a/src/deplibs/libmplphase.a and b/src/deplibs/libmplphase.a differ
diff --git a/src/deplibs/libmplutil.a b/src/deplibs/libmplutil.a
index bf31a7baec611102050f3e8b51cca6ce0974c064..cbee045db01565b850160591652763d5d734487d 100644
Binary files a/src/deplibs/libmplutil.a and b/src/deplibs/libmplutil.a differ
diff --git a/src/maple_driver/include/compiler.h b/src/maple_driver/include/compiler.h
index 23376d5009ae062d5400d5d04faf82b2fa753755..ba16aff935aaee766a190e24cbd36be03f53657a 100644
--- a/src/maple_driver/include/compiler.h
+++ b/src/maple_driver/include/compiler.h
@@ -38,7 +38,7 @@ class Compiler {
 
   virtual ~Compiler() = default;
 
-  virtual ErrorCode Compile(const MplOptions &options, MIRModulePtr &theModule);
+  virtual ErrorCode Compile(const MplOptions &options, std::unique_ptr<MIRModule> &theModule);
 
   virtual void GetTmpFilesToDelete(const MplOptions&, std::vector<std::string>&) const {}
 
@@ -70,11 +70,13 @@ class Compiler {
   const std::string name;
   std::string MakeOption(const MplOptions &options) const;
   void AppendDefaultOptions(std::map<std::string, MplOption> &finalOptions,
-                            const std::map<std::string, MplOption> &defaultOptions) const;
+                            const std::map<std::string, MplOption> &defaultOptions,
+                            std::ostringstream &strOption, bool isDebug) const;
   void AppendOptions(std::map<std::string, MplOption> &finalOptions, const std::string &key,
                      const std::string &value) const;
   void AppendExtraOptions(std::map<std::string, MplOption> &finalOptions,
-                          const std::map<std::string, std::vector<MplOption>> &extraOptions) const;
+                          const MplOptions &options,
+                          std::ostringstream &strOption, bool isDebug) const;
   std::map<std::string, MplOption> MakeDefaultOptions(const MplOptions &options) const;
   int Exe(const MplOptions &mplOptions, const std::string &options) const;
   const std::string &GetName() const {
@@ -101,7 +103,7 @@ class MapleCombCompiler : public Compiler {
 
   ~MapleCombCompiler() = default;
 
-  ErrorCode Compile(const MplOptions &options, MIRModulePtr &theModule) override;
+  ErrorCode Compile(const MplOptions &options, std::unique_ptr<MIRModule> &theModule) override;
   void PrintCommand(const MplOptions &options) const override;
   std::string GetInputFileName(const MplOptions &options) const override;
 
@@ -118,7 +120,7 @@ class MplcgCompiler : public Compiler {
   explicit MplcgCompiler(const std::string &name) : Compiler(name) {}
 
   ~MplcgCompiler() = default;
-  ErrorCode Compile(const MplOptions &options, MIRModulePtr &theModule) override;
+  ErrorCode Compile(const MplOptions &options, std::unique_ptr<MIRModule> &theModule) override;
   void PrintCommand(const MplOptions &options) const override;
  private:
   std::string GetInputFileName(const MplOptions &options) const override;
diff --git a/src/maple_driver/include/compiler_factory.h b/src/maple_driver/include/compiler_factory.h
index d6dc772338e547173a0108c254356f54ee807343..1d85b92d3ee9196e3df3f76661c34fcc18d6ec14 100644
--- a/src/maple_driver/include/compiler_factory.h
+++ b/src/maple_driver/include/compiler_factory.h
@@ -40,7 +40,7 @@ class CompilerFactory {
                            const std::unordered_set<std::string> &finalOutputs) const;
   SupportedCompilers supportedCompilers;
   CompilerSelector *compilerSelector;
-  MIRModule *theModule = nullptr;
+  std::unique_ptr<MIRModule> theModule;
 };
 }  // namespace maple
 #endif  // MAPLE_DRIVER_INCLUDE_COMPILER_FACTORY_H
diff --git a/src/maple_driver/include/driver_runner.h b/src/maple_driver/include/driver_runner.h
index 8ed6b444feb22914178baebcff0af0cf5647f784..77f435f7d82c81be73e513a9bd95c62b5c870776 100644
--- a/src/maple_driver/include/driver_runner.h
+++ b/src/maple_driver/include/driver_runner.h
@@ -34,7 +34,7 @@ class DriverRunner final {
  public:
   DriverRunner(MIRModule *theModule, const std::vector<std::string> &exeNames, Options *mpl2mplOptions,
                std::string mpl2mplInput, MeOption *meOptions, const std::string &meInput, std::string actualInput,
-               MemPool *optMp, bool timePhases = false,
+               MemPool *optMp, bool fileParsed = false, bool timePhases = false,
                bool genVtableImpl = false, bool genMeMpl = false)
       : theModule(theModule),
         exeNames(exeNames),
@@ -44,14 +44,15 @@ class DriverRunner final {
         meInput(meInput),
         actualInput(actualInput),
         optMp(optMp),
+        fileParsed(fileParsed),
         timePhases(timePhases),
         genVtableImpl(genVtableImpl),
         genMeMpl(genMeMpl) {}
 
   DriverRunner(MIRModule *theModule, const std::vector<std::string> &exeNames, std::string actualInput, MemPool *optMp,
-               bool timePhases = false, bool genVtableImpl = false, bool genMeMpl = false)
-      : DriverRunner(theModule, exeNames, nullptr, "", nullptr, "", actualInput, optMp, timePhases, genVtableImpl,
-                     genMeMpl) {}
+               bool fileParsed = false, bool timePhases = false, bool genVtableImpl = false, bool genMeMpl = false)
+      : DriverRunner(theModule, exeNames, nullptr, "", nullptr, "", actualInput, optMp, fileParsed, timePhases,
+                     genVtableImpl, genMeMpl) {}
 
   ~DriverRunner() = default;
 
@@ -62,8 +63,6 @@ class DriverRunner final {
     this->cgInput = cgInput;
   }
  private:
-  static bool FuncOrderLessThan(const MIRFunction *left, const MIRFunction *right);
-
   bool IsFramework() const;
   ErrorCode ParseInput(const std::string &outputFile, const std::string &oriBasename) const;
   std::string GetPostfix() const;
@@ -90,6 +89,7 @@ class DriverRunner final {
   std::string meInput;
   std::string actualInput;
   MemPool *optMp;
+  bool fileParsed = false;
   bool timePhases = false;
   bool genVtableImpl = false;
   bool genMeMpl = false;
diff --git a/src/maple_driver/include/mpl_options.h b/src/maple_driver/include/mpl_options.h
index 19a848a83b90deed56320e327cfa4a7379a39be1..be24bb47340dc0080831c054df292fd650c65a42 100644
--- a/src/maple_driver/include/mpl_options.h
+++ b/src/maple_driver/include/mpl_options.h
@@ -29,12 +29,12 @@
 
 namespace maple {
 enum InputFileType {
-  kNone,
-  kClass,
-  kJar,
-  kMpl,
-  kVtableImplMpl,
-  kS,
+  kFileTypeNone,
+  kFileTypeClass,
+  kFileTypeJar,
+  kFileTypeMpl,
+  kFileTypeVtableImplMpl,
+  kFileTypeS,
 };
 
 enum OptimizationLevel {
@@ -126,6 +126,10 @@ class MplOptions {
     return optimizationLevel;
   }
 
+  const std::string &GetMpltFile() const {
+    return mpltFile;
+  }
+
   bool HasSetDefaultLevel() const {
     return setDefaultLevel;
   }
@@ -192,7 +196,8 @@ class MplOptions {
   std::string outputFolder = "";
   std::string outputName = "maple";
   std::string exeFolder = "";
-  InputFileType inputFileType = InputFileType::kNone;
+  std::string mpltFile = "";
+  InputFileType inputFileType = InputFileType::kFileTypeNone;
   OptimizationLevel optimizationLevel = OptimizationLevel::kO0;
   RunMode runMode = RunMode::kUnkownRun;
   bool setDefaultLevel = false;
diff --git a/src/maple_driver/src/compiler.cpp b/src/maple_driver/src/compiler.cpp
index 08dbbdb991f539d53f514f27f5cd3a8032e963be..495ba5827acbbc17947eef98e38b6d7db374ac55 100644
--- a/src/maple_driver/src/compiler.cpp
+++ b/src/maple_driver/src/compiler.cpp
@@ -42,7 +42,7 @@ std::string Compiler::GetBinPath(const MplOptions &mplOptions) const {
   return binPath;
 }
 
-ErrorCode Compiler::Compile(const MplOptions &options, MIRModulePtr&) {
+ErrorCode Compiler::Compile(const MplOptions &options, std::unique_ptr<MIRModule> &) {
   MPLTimer timer = MPLTimer();
   LogInfo::MapleLogger() << "Starting " << GetName() << '\n';
   timer.Start();
@@ -61,16 +61,9 @@ ErrorCode Compiler::Compile(const MplOptions &options, MIRModulePtr&) {
 std::string Compiler::MakeOption(const MplOptions &options) const {
   std::map<std::string, MplOption> finalOptions;
   std::map<std::string, MplOption> defaultOptions = MakeDefaultOptions(options);
-  AppendDefaultOptions(finalOptions, defaultOptions);
-  AppendExtraOptions(finalOptions, options.GetExtras());
   std::ostringstream strOption;
-  for (const auto &finalOption : finalOptions) {
-    strOption << " " << finalOption.first << " " << finalOption.second.GetValue();
-    if (options.HasSetDebugFlag()) {
-      LogInfo::MapleLogger() << Compiler::GetName() << " options: " << finalOption.first << " "
-                             << finalOption.second.GetValue() << '\n';
-    }
-  }
+  AppendDefaultOptions(finalOptions, defaultOptions, strOption, options.HasSetDebugFlag());
+  AppendExtraOptions(finalOptions, options, strOption, options.HasSetDebugFlag());
   strOption << " " << this->GetInputFileName(options);
   if (options.HasSetDebugFlag()) {
     LogInfo::MapleLogger() << Compiler::GetName() << " input files: " << GetInputFileName(options) << '\n';
@@ -79,21 +72,44 @@ std::string Compiler::MakeOption(const MplOptions &options) const {
 }
 
 void Compiler::AppendDefaultOptions(std::map<std::string, MplOption> &finalOptions,
-                                    const std::map<std::string, MplOption> &defaultOptions) const {
+                                    const std::map<std::string, MplOption> &defaultOptions,
+                                    std::ostringstream &strOption, bool isDebug) const {
   for (const auto &defaultIt : defaultOptions) {
     (void)finalOptions.insert(make_pair(defaultIt.first, defaultIt.second));
+    strOption << " " << defaultIt.first << " " << defaultIt.second.GetValue();
+    if (isDebug) {
+      LogInfo::MapleLogger() << Compiler::GetName() << " options: " << defaultIt.first << " "
+                             << defaultIt.second.GetValue() << '\n';
+    }
   }
 }
 
 void Compiler::AppendExtraOptions(std::map<std::string, MplOption> &finalOptions,
-                                  const std::map<std::string, std::vector<MplOption>> &extraOptions) const {
+                                  const MplOptions &options,
+                                  std::ostringstream &strOption, bool isDebug) const {
   const std::string &binName = GetBinName();
-  auto extras = extraOptions.find(binName);
-  if (extras == extraOptions.end()) {
+  auto exeOption = options.GetExeOptions().find(binName);
+  if (exeOption == options.GetExeOptions().end()) {
     return;
   }
-  for (const auto &secondExtras : extras->second) {
+  std::map<std::string, std::vector<MplOption>> extraOptions = options.GetExtras();
+  auto &extraOption = extraOptions[binName];
+  for (size_t i = 0; i < exeOption->second.size(); ++i) {
+    if (exeOption->second[i].Args() != "") {
+      MplOption mplOption("-" + exeOption->second[i].OptionKey(), exeOption->second[i].Args());
+      extraOption.push_back(mplOption);
+    } else {
+      MplOption mplOption("-" + exeOption->second[i].OptionKey(), "");
+      extraOption.push_back(mplOption);
+    }
+  }
+  for (const auto &secondExtras : extraOption) {
     AppendOptions(finalOptions, secondExtras.GetKey(), secondExtras.GetValue());
+    strOption << " " << secondExtras.GetKey() << " " << secondExtras.GetValue();
+    if (isDebug) {
+      LogInfo::MapleLogger() << Compiler::GetName() << " options: " << secondExtras.GetKey() << " "
+                             << secondExtras.GetValue() << '\n';
+    }
   }
 }
 
@@ -103,7 +119,7 @@ std::map<std::string, MplOption> Compiler::MakeDefaultOptions(const MplOptions &
   if (rawDefaultOptions.mplOptions != nullptr) {
     for (uint32_t i = 0; i < rawDefaultOptions.length; ++i) {
       (void)defaultOptions.insert(std::make_pair(rawDefaultOptions.mplOptions[i].GetKey(),
-          rawDefaultOptions.mplOptions[i]));
+                                  rawDefaultOptions.mplOptions[i]));
     }
   }
   return defaultOptions;
diff --git a/src/maple_driver/src/compiler_factory.cpp b/src/maple_driver/src/compiler_factory.cpp
index e2a1bd1e5fc3e867147b235a752aea2c947c6537..05451f95865032c8c575f6d5e65252e50e999a08 100644
--- a/src/maple_driver/src/compiler_factory.cpp
+++ b/src/maple_driver/src/compiler_factory.cpp
@@ -53,10 +53,6 @@ CompilerFactory::~CompilerFactory() {
     delete compilerSelector;
     compilerSelector = nullptr;
   }
-  if (theModule != nullptr) {
-    delete theModule;
-    theModule = nullptr;
-  }
 }
 
 void CompilerFactory::Insert(const std::string &name, Compiler *value) {
diff --git a/src/maple_driver/src/driver_runner.cpp b/src/maple_driver/src/driver_runner.cpp
index c64b617a3e0591e56615ef4a8310f76cfcbc6f7b..5400b23a95a1f483f5ae9ef98c083ce799230586 100644
--- a/src/maple_driver/src/driver_runner.cpp
+++ b/src/maple_driver/src/driver_runner.cpp
@@ -19,6 +19,7 @@
 #include "mpl_timer.h"
 #include "mir_function.h"
 #include "mir_parser.h"
+#include "file_utils.h"
 
 #include "lower.h"
 #if TARGAARCH64
@@ -104,10 +105,6 @@ ErrorCode DriverRunner::Run() {
   return kErrorNoError;
 }
 
-bool DriverRunner::FuncOrderLessThan(const MIRFunction *left, const MIRFunction *right) {
-  return left->GetLayoutType() < right->GetLayoutType();
-}
-
 bool DriverRunner::IsFramework() const {
   return false;
 }
@@ -134,10 +131,13 @@ ErrorCode DriverRunner::ParseInput(const std::string &outputFile, const std::str
 
   MIRParser parser(*theModule);
   ErrorCode ret = kErrorNoError;
-  bool parsed = parser.ParseMIR(0, 0, false, true);
-  if (!parsed) {
-    ret = kErrorExit;
-    parser.EmitError(outputFile);
+  bool parsed;
+  if (!fileParsed) {
+    parsed = parser.ParseMIR(0, 0, false, true);
+    if (!parsed) {
+      ret = kErrorExit;
+      parser.EmitError(outputFile);
+    }
   }
   timer.Stop();
   LogInfo::MapleLogger() << "Parse consumed " << timer.Elapsed() << "s" << '\n';
diff --git a/src/maple_driver/src/maple_comb_compiler.cpp b/src/maple_driver/src/maple_comb_compiler.cpp
index 52ae7fcac69d20f772daaad258b56e8814933ee9..3742816892f8e9486ab71e33c80022c2b4ab44b1 100644
--- a/src/maple_driver/src/maple_comb_compiler.cpp
+++ b/src/maple_driver/src/maple_comb_compiler.cpp
@@ -28,7 +28,7 @@ std::string MapleCombCompiler::GetInputFileName(const MplOptions &options) const
       return options.GetInputFiles();
     }
   }
-  if (options.GetInputFileType() == InputFileType::kVtableImplMpl) {
+  if (options.GetInputFileType() == InputFileType::kFileTypeVtableImplMpl) {
     return options.GetOutputFolder() + options.GetOutputName() + ".VtableImpl.mpl";
   }
   return options.GetOutputFolder() + options.GetOutputName() + ".mpl";
@@ -106,7 +106,7 @@ bool MapleCombCompiler::MakeMeOptions(const MplOptions &options) {
   }
   bool result = meOption.SolveOptions(it->second, options.HasSetDebugFlag());
   if (result == false) {
-    LogInfo::MapleLogger() << "Meet error mpl2mpl options\n";
+    LogInfo::MapleLogger() << "Meet error me options\n";
     return false;
   }
   return true;
@@ -127,10 +127,14 @@ bool MapleCombCompiler::MakeMpl2MplOptions(const MplOptions &options) {
   return true;
 }
 
-ErrorCode MapleCombCompiler::Compile(const MplOptions &options, MIRModulePtr &theModule) {
+ErrorCode MapleCombCompiler::Compile(const MplOptions &options, std::unique_ptr<MIRModule> &theModule) {
   MemPool *optMp = memPoolCtrler.NewMemPool("maplecomb mempool");
   std::string fileName = GetInputFileName(options);
-  theModule = new MIRModule(fileName);
+  bool fileParsed = true;
+  if (theModule == nullptr) {
+    theModule = std::make_unique<MIRModule>(fileName);
+    fileParsed = false;
+  }
   MeOption &meOptions = MeOption::GetInstance();
   Options &mpl2mplOptions = Options::GetInstance();
   auto it = std::find(options.GetRunningExes().begin(), options.GetRunningExes().end(), kBinNameMe);
@@ -150,8 +154,8 @@ ErrorCode MapleCombCompiler::Compile(const MplOptions &options, MIRModulePtr &th
 
   LogInfo::MapleLogger() << "Starting mpl2mpl&mplme\n";
   PrintCommand(options);
-  DriverRunner runner(theModule, options.GetRunningExes(), &mpl2mplOptions, fileName, &meOptions,
-                      fileName, fileName, optMp,
+  DriverRunner runner(theModule.get(), options.GetRunningExes(), &mpl2mplOptions, fileName, &meOptions,
+                      fileName, fileName, optMp, fileParsed,
                       options.HasSetTimePhases(), options.HasSetGenVtableImpl(), options.HasSetGenMeMpl());
   ErrorCode nErr = runner.Run();
 
diff --git a/src/maple_driver/src/mpl_options.cpp b/src/maple_driver/src/mpl_options.cpp
index 61b02ffae015a5ecf2c31b9df63f376428b9e319..6e3ab5adcb90f261b89f45364a9054af698d7da3 100644
--- a/src/maple_driver/src/mpl_options.cpp
+++ b/src/maple_driver/src/mpl_options.cpp
@@ -151,6 +151,7 @@ ErrorCode MplOptions::HandleGeneralOptions() {
         }
         break;
       case kInMplt:
+        mpltFile = opt.Args();
         break;
       case kAllDebug:
         debugFlag = true;
@@ -161,6 +162,7 @@ ErrorCode MplOptions::HandleGeneralOptions() {
     }
     ret = AddOption(opt);
   }
+
   return ret;
 }
 
@@ -218,20 +220,20 @@ ErrorCode MplOptions::DecideRunningPhases() {
   bool isNeedMapleComb = true;
   bool isNeedMplcg = true;
   switch (inputFileType) {
-    case InputFileType::kJar:
+    case InputFileType::kFileTypeJar:
       // fall-through
-    case InputFileType::kClass:
+    case InputFileType::kFileTypeClass:
       UpdateRunningExe(kBinNameJbc2mpl);
       break;
-    case InputFileType::kMpl:
+    case InputFileType::kFileTypeMpl:
       break;
-    case InputFileType::kVtableImplMpl:
+    case InputFileType::kFileTypeVtableImplMpl:
       isNeedMapleComb = false;
       break;
-    case InputFileType::kS:
+    case InputFileType::kFileTypeS:
       isNeedMplcg = false;
       break;
-    case InputFileType::kNone:
+    case InputFileType::kFileTypeNone:
       break;
     default:
       break;
@@ -302,16 +304,6 @@ ErrorCode MplOptions::AddOption(const mapleOption::Option &option) {
     }
     // For compilers, such as me, mpl2mpl
     exeOptions[exeName].push_back(option);
-    // Fill extraOption
-    // For compiler bins called by system()
-    auto &extraOption = extras[exeName];
-    if (option.Args() != "") {
-      MplOption mplOption("-" + option.OptionKey(), option.Args());
-      extraOption.push_back(mplOption);
-    } else {
-      MplOption mplOption("-" + option.OptionKey(), "");
-      extraOption.push_back(mplOption);
-    }
   }
   return kErrorNoError;
 }
@@ -328,18 +320,18 @@ bool MplOptions::Init(const std::string &inputFile) {
   outputName = FileUtils::GetFileName(firstInputFile, false);
   std::string extensionName = FileUtils::GetFileExtension(firstInputFile);
   if (extensionName == "class") {
-    inputFileType = InputFileType::kClass;
+    inputFileType = InputFileType::kFileTypeClass;
   }
   else if (extensionName == "jar") {
-    inputFileType = InputFileType::kJar;
+    inputFileType = InputFileType::kFileTypeJar;
   } else if (extensionName == "mpl") {
     if (firstInputFile.find("VtableImpl") == std::string::npos) {
-      inputFileType = InputFileType::kMpl;
+      inputFileType = InputFileType::kFileTypeMpl;
     } else {
-      inputFileType = InputFileType::kVtableImplMpl;
+      inputFileType = InputFileType::kFileTypeVtableImplMpl;
     }
   } else if (extensionName == "s") {
-    inputFileType = InputFileType::kS;
+    inputFileType = InputFileType::kFileTypeS;
   } else {
     return false;
   }
@@ -419,18 +411,6 @@ ErrorCode MplOptions::UpdatePhaseOption(const std::string &args, const std::stri
   if (ret != kErrorNoError) {
     return ret;
   }
-  // Fill extraOption
-  // For compiler bins called by system()
-  auto &extraOption = extras[exeName];
-  for (size_t i = 0; i < exeOption.size(); ++i) {
-    if (exeOption[i].Args() != "") {
-      MplOption mplOption("-" + exeOption[i].OptionKey(), exeOption[i].Args());
-      extraOption.push_back(mplOption);
-    } else {
-      MplOption mplOption("-" + exeOption[i].OptionKey(), "");
-      extraOption.push_back(mplOption);
-    }
-  }
   return ret;
 }
 
diff --git a/src/maple_driver/src/mplcg_compiler.cpp b/src/maple_driver/src/mplcg_compiler.cpp
index 516fca1cb160b8d4d7535c7df9f3c48a4d757e8d..d56535abaae87a79370bf375d43c4eb618d4825c 100644
--- a/src/maple_driver/src/mplcg_compiler.cpp
+++ b/src/maple_driver/src/mplcg_compiler.cpp
@@ -97,7 +97,7 @@ bool MplcgCompiler::MakeCGOptions(const MplOptions &options) {
   return true;
 }
 
-ErrorCode MplcgCompiler::Compile(const MplOptions &options, MIRModulePtr &theModule) {
+ErrorCode MplcgCompiler::Compile(const MplOptions &options, std::unique_ptr<MIRModule> &theModule) {
   MemPool *optMp = memPoolCtrler.NewMemPool("maplecg mempool");
   CGOptions &cgOption = CGOptions::GetInstance();
   bool result = MakeCGOptions(options);
@@ -109,10 +109,12 @@ ErrorCode MplcgCompiler::Compile(const MplOptions &options, MIRModulePtr &theMod
   std::string output = baseName + ".s";
   bool parsed = false;
   std::unique_ptr<MIRParser> theParser;
+  bool fileparsed = true;
   if (theModule == nullptr) {
     MPLTimer timer;
     timer.Start();
-    theModule = new MIRModule(fileName);
+    fileparsed = false;
+    theModule = std::make_unique<MIRModule>(fileName);
     theModule->SetWithMe(
         std::find(options.GetRunningExes().begin(), options.GetRunningExes().end(),
                   kBinNameMe) != options.GetRunningExes().end());
@@ -134,7 +136,8 @@ ErrorCode MplcgCompiler::Compile(const MplOptions &options, MIRModulePtr &theMod
   }
 
   LogInfo::MapleLogger() << "Starting mplcg\n";
-  DriverRunner runner(theModule, options.GetRunningExes(), fileName, optMp, options.HasSetTimePhases());
+  DriverRunner runner(theModule.get(), options.GetRunningExes(), fileName, optMp,
+      fileparsed, options.HasSetTimePhases());
   PrintCommand(options);
   runner.SetCGInfo(&cgOption, fileName);
   runner.ProcessCGPhase(output, baseName);
diff --git a/src/maple_ipa/src/clone.cpp b/src/maple_ipa/src/clone.cpp
index 96a4eeea0f202b94fb992a49e242bf7e3e4aec34..0b1e8345c9316e0781bb3e906090a23a7f0806f3 100644
--- a/src/maple_ipa/src/clone.cpp
+++ b/src/maple_ipa/src/clone.cpp
@@ -127,6 +127,10 @@ MIRFunction *Clone::CloneFunction(MIRFunction &originalFunction, const std::stri
     CloneLabels(*newFunc, originalFunction);
     mirBuilder.SetCurrentFunction(*originalCurrFunction);
   }
+  // clone pregIndex
+  if (newFunc->GetPregTab() != nullptr && originalFunction.GetPregTab() != nullptr) {
+    newFunc->GetPregTab()->SetIndex(originalFunction.GetPregTab()->GetIndex());
+  }
   return newFunc;
 }
 
diff --git a/src/maple_ir/include/mir_function.h b/src/maple_ir/include/mir_function.h
index 80e1aa7c8a1cea52b48348be4528cdf0aabac8dd..e0e17bc0cb9907daf7cc6f9257920a95ded26aed 100644
--- a/src/maple_ir/include/mir_function.h
+++ b/src/maple_ir/include/mir_function.h
@@ -442,6 +442,11 @@ class MIRFunction {
     inferredReturnTyIdx = tyIdx;
   }
 
+  void AllocTypeNameTab() {
+    if (typeNameTab == nullptr) {
+      typeNameTab = module->GetMemPool()->New<MIRTypeNameTable>(module->GetMPAllocator());
+    }
+  }
   bool HaveTypeNameTab() {
     return typeNameTab != nullptr;
   }
@@ -463,6 +468,11 @@ class MIRFunction {
     return labelTab->GetName(labelIdx);
   }
 
+  void AllocLabelTab() {
+    if (labelTab == nullptr) {
+      labelTab = module->GetMemPool()->New<MIRLabelTable>(module->GetMPAllocator());
+    }
+  }
   MIRPregTable *GetPregTab() {
     return pregTab;
   }
@@ -472,6 +482,11 @@ class MIRFunction {
   void SetPregTab(MIRPregTable *tab) {
     pregTab = tab;
   }
+  void AllocPregTab() {
+    if (pregTab == nullptr) {
+      pregTab = module->GetMemPool()->New<MIRPregTable>(module, &module->GetMPAllocator());
+    }
+  }
   MIRPreg *GetPregItem(PregIdx idx) {
     return const_cast<MIRPreg*>(const_cast<const MIRFunction*>(this)->GetPregItem(idx));
   }
@@ -717,7 +732,11 @@ class MIRFunction {
   MIRSymbolTable *GetSymTab() {
     return symTab;
   }
-
+  void AllocSymTab() {
+    if (symTab == nullptr) {
+      symTab = module->GetMemPool()->New<MIRSymbolTable>(module->GetMPAllocator());
+    }
+  }
   const MIRLabelTable *GetLabelTab() const {
     CHECK_FATAL(labelTab != nullptr, "must be");
     return labelTab;
diff --git a/src/maple_ir/include/mir_parser.h b/src/maple_ir/include/mir_parser.h
index da6d05c23f0fa62c913673d7ff03928c8b8747ba..3764cbd7128c6af78ea0d25f8a6d5908a23cc325 100644
--- a/src/maple_ir/include/mir_parser.h
+++ b/src/maple_ir/include/mir_parser.h
@@ -190,6 +190,7 @@ class MIRParser {
   const std::string &GetWarning() const;
   bool ParseFuncInfo(void);
   void PrepareParsingMIR();
+  void PrepareParsingMplt();
   bool ParseMIR(uint32 fileIdx = 0, uint32 option = 0, bool isIpa = false, bool isComb = false);
   bool ParseMIR(std::ifstream&);  // the main entry point
   bool ParseMPLT(std::ifstream&, const std::string&);
diff --git a/src/maple_ir/include/mir_symbol.h b/src/maple_ir/include/mir_symbol.h
index ab3901fd982626be498108899bc24587cb84994a..6420fc8f37f4a973186d1f23cf5442d09d3f7d80 100644
--- a/src/maple_ir/include/mir_symbol.h
+++ b/src/maple_ir/include/mir_symbol.h
@@ -113,6 +113,13 @@ class MIRSymbol {
   void SetIsTmpUnused(bool used) {
     isTmpUnused = used;
   }
+  void SetIsImportedDecl(bool imported) {
+    isImportedDecl = imported;
+  }
+
+  bool GetIsImportedDecl() const {
+    return isImportedDecl;
+  }
 
   bool IsTmpUnused() const {
     return isTmpUnused;
@@ -408,6 +415,7 @@ class MIRSymbol {
   bool isDeleted = false;     // tell if it is deleted, NOT serialized
   bool instrumented = false;  // a local ref pointer instrumented by RC opt, NOT serialized
   bool isImported = false;
+  bool isImportedDecl = false;
   bool isTmpUnused = false;  // when parse the mplt_inline file, mark all the new symbol as tmpunused
   StIdx stIdx { 0, 0 };
   TypeAttrs typeAttrs;
diff --git a/src/maple_ir/include/mir_type.h b/src/maple_ir/include/mir_type.h
index cdaa18c32e7646452fc066cefa831580d10220b5..0422ff9ca9e46eb9c241df867975caca0701ca17 100755
--- a/src/maple_ir/include/mir_type.h
+++ b/src/maple_ir/include/mir_type.h
@@ -399,7 +399,7 @@ class MIRType {
   virtual void Dump(int indent, bool dontUseName = false) const;
   virtual void DumpAsCxx(int indent) const;
   virtual bool EqualTo(const MIRType &mirType) const;
-  virtual bool IsStructType() {
+  virtual bool IsStructType() const {
     return false;
   }
 
@@ -722,7 +722,7 @@ class MIRStructType : public MIRType {
 
   ~MIRStructType() override = default;
 
-  bool IsStructType() override {
+  bool IsStructType() const override {
     return true;
   }
 
diff --git a/src/maple_ir/include/option.h b/src/maple_ir/include/option.h
index fe9137f2afc073b153668196f053c2f4f55c1cc6..b0d06d12cc89c15466e797eeb1a4991f541c1a43 100644
--- a/src/maple_ir/include/option.h
+++ b/src/maple_ir/include/option.h
@@ -99,6 +99,7 @@ class Options : public MapleDriverOptionBase {
   static bool genIRProfile;
   static bool profileTest;
   static bool checkArrayStore;
+  static bool noComment;
  private:
   void DecideMpl2MplRealLevel(const std::vector<mapleOption::Option> &inputOptions) const;
   std::vector<std::string> phaseSeq;
diff --git a/src/maple_ir/src/bin_mpl_import.cpp b/src/maple_ir/src/bin_mpl_import.cpp
index 5f709e928a2dd53c88f6ca661913ee33742fc1bb..33c07d98158b93bfcf746617da08a21815f20f54 100755
--- a/src/maple_ir/src/bin_mpl_import.cpp
+++ b/src/maple_ir/src/bin_mpl_import.cpp
@@ -299,6 +299,7 @@ void BinaryMplImport::ImportMethodPair(MethodPair &memPool) {
     funcSt->SetSKind(kStFunc);
     funcSt->SetTyIdx(funcTyIdx);
     funcSt->SetIsImported(imported);
+    funcSt->SetIsImportedDecl(imported);
     methodSymbols.push_back(funcSt);
 
     fn = mod.GetMemPool()->New<MIRFunction>(&mod, funcSt->GetStIdx());
diff --git a/src/maple_ir/src/mir_module.cpp b/src/maple_ir/src/mir_module.cpp
index e14241106337058272de8c8fe886ce060769cdba..0123e0f017d2197d4536612b7e8c102d14619735 100644
--- a/src/maple_ir/src/mir_module.cpp
+++ b/src/maple_ir/src/mir_module.cpp
@@ -266,7 +266,7 @@ void MIRModule::DumpGlobals(bool emitStructureType) const {
       if (s->IsJavaClassInterface()) {
         continue;
       }
-      if (!s->IsDeleted() && !s->GetIsImported()) {
+      if (!s->IsDeleted() && !s->GetIsImported() && !s->GetIsImportedDecl()) {
         s->Dump(false, 0);
       }
     }
diff --git a/src/maple_ir/src/mir_parser.cpp b/src/maple_ir/src/mir_parser.cpp
index 8d14fe8c2fbb5aecdcdc61a6de305d1bca5b59b4..be7b16a46215b8517f8943f1738e2a84b508ac97 100644
--- a/src/maple_ir/src/mir_parser.cpp
+++ b/src/maple_ir/src/mir_parser.cpp
@@ -1436,6 +1436,10 @@ bool MIRParser::ParseStmtBlock(BlockNodePtr &blk) {
 }
 
 void MIRParser::ParseStmtBlockForSeenComment(BlockNodePtr blk, uint32 mplNum) {
+  if (Options::noComment) {
+    lexer.seenComments.clear();
+    return;
+  }
   // collect accumulated comments into comment statement nodes
   if (!lexer.seenComments.empty()) {
     for (size_t i = 0; i < lexer.seenComments.size(); ++i) {
diff --git a/src/maple_ir/src/mir_type.cpp b/src/maple_ir/src/mir_type.cpp
index c7a17a1f33ff49f95654dca86af265d80e323ae5..741f1c88add0bf1f1157e67f46646359392daf11 100755
--- a/src/maple_ir/src/mir_type.cpp
+++ b/src/maple_ir/src/mir_type.cpp
@@ -964,6 +964,9 @@ uint32 MIRClassType::GetInfo(const std::string &infoStr) const {
 }
 
 bool MIRClassType::IsFinal() const {
+  if (!IsStructType()) {
+    return false;
+  }
   uint32 attrStrIdx = GetInfo(GlobalTables::GetStrTable().GetOrCreateStrIdxFromName("INFO_attribute_string"));
   CHECK(attrStrIdx < GlobalTables::GetStrTable().StringTableSize(), "out of range of vector");
   const std::string &kAttrString = GlobalTables::GetStrTable().GetStringFromStrIdx(GStrIdx(attrStrIdx));
diff --git a/src/maple_ir/src/option.cpp b/src/maple_ir/src/option.cpp
index 79843c750e959f918f0925117db65459a4e4980d..4a2fed517c5d68b199e35c5926192966f40e9e39 100644
--- a/src/maple_ir/src/option.cpp
+++ b/src/maple_ir/src/option.cpp
@@ -66,6 +66,8 @@ std::string Options::proFileData = "";
 std::string Options::proFileFuncData = "";
 std::string Options::proFileClassData = "";
 bool Options::checkArrayStore = false;
+bool Options::noComment = false;
+
 enum OptionIndex {
   kMpl2MplDumpPhase = kCommonOptionEnd + 1,
   kMpl2MplSkipPhase,
@@ -103,6 +105,7 @@ enum OptionIndex {
   kMpl2MplNoDot,
   kGenIRProfile,
   kProfileTest,
+  kNoComment
 };
 
 const Descriptor kUsage[] = {
@@ -446,6 +449,15 @@ const Descriptor kUsage[] = {
     "  --no-profile-test           \tDisable profile test\n",
     "mpl2mpl",
     {} },
+  { kNoComment,
+    0,
+    "",
+    "no-comment",
+    kBuildTypeProduct,
+    kArgCheckPolicyBool,
+    "  --no-comment             \tbuild inlineCache 0:off, 1:open\n",
+    "mpl2mpl",
+    {} },
   { kUnknown,
     0,
     "",
@@ -651,6 +663,9 @@ bool Options::SolveOptions(const std::vector<Option> &opts, bool isDebug) const
       case kProfileTest:
         profileTest = (opt.Type() == kEnable);
         break;
+      case kNoComment:
+        noComment = true;
+        break;
       default:
         WARN(kLncWarn, "input invalid key for mpl2mpl " + opt.OptionKey());
         break;
diff --git a/src/maple_ir/src/parser.cpp b/src/maple_ir/src/parser.cpp
index 8fb3200792a24894d071acfe251fcdce9a8a4ae9..9d6e167e50831a5f8fe7bf5f7a4cfe3b72e781ea 100755
--- a/src/maple_ir/src/parser.cpp
+++ b/src/maple_ir/src/parser.cpp
@@ -2714,6 +2714,10 @@ void MIRParser::PrepareParsingMIR() {
   lexer.PrepareForFile(mod.GetFileName());
 }
 
+void MIRParser::PrepareParsingMplt() {
+  lexer.PrepareForFile(mod.GetFileName());
+}
+
 bool MIRParser::ParseTypeFromString(const std::string &src, TyIdx &tyIdx) {
   lexer.PrepareForString(src);
   return ParseType(tyIdx);
diff --git a/src/maple_me/src/me_loop_canon.cpp b/src/maple_me/src/me_loop_canon.cpp
index 916a6818b03d6300373c92e1ad2aa42c1068a8e6..4915ae5c7586b3c1f9e8384ed3893c539953e55f 100644
--- a/src/maple_me/src/me_loop_canon.cpp
+++ b/src/maple_me/src/me_loop_canon.cpp
@@ -547,12 +547,16 @@ void MeDoLoopCanon::ExecuteLoopNormalization(MeFunction &func,  MeFuncResultMgr
   FindHeadBBs(func, dom, func.GetCommonEntryBB());
   AddPreheader(func);
   Merge(func);
-  m->InvalidAnalysisResult(MeFuncPhase_DOMINANCE, &func);
-  m->InvalidAnalysisResult(MeFuncPhase_MELOOP, &func);
+  // cfg changes only if heads is not empty
+  if (!heads.empty()) {
+    m->InvalidAnalysisResult(MeFuncPhase_DOMINANCE, &func);
+    m->InvalidAnalysisResult(MeFuncPhase_MELOOP, &func);
+  }
   IdentifyLoops *meLoop = static_cast<IdentifyLoops*>(m->GetAnalysisResult(MeFuncPhase_MELOOP, &func));
   if (meLoop == nullptr) {
     return;
   }
+  bool cfgChange = false;
   for (auto loop : meLoop->GetMeLoops()) {
     if (loop->HasTryBB()) {
       continue;
@@ -562,10 +566,12 @@ void MeDoLoopCanon::ExecuteLoopNormalization(MeFunction &func,  MeFuncResultMgr
       CHECK_FATAL(loop->inloopBB2exitBBs.size() == 0, "must be zero");
       InsertExitBB(func, *loop);
       loop->SetIsCanonicalLoop(true);
+      cfgChange = true;
     }
     if (loop->inloopBB2exitBBs.size() == 1 && loop->inloopBB2exitBBs.begin()->second->size() == 1 &&
         IsDoWhileLoop(func, *loop)) {
       SplitCondGotBB(func, *loop);
+      cfgChange = true;
     }
   }
   if (DEBUGFUNC(&func)) {
@@ -573,8 +579,10 @@ void MeDoLoopCanon::ExecuteLoopNormalization(MeFunction &func,  MeFuncResultMgr
     func.Dump(true);
     func.GetTheCfg()->DumpToFile("cfgafterLoopNormalization");
   }
-  m->InvalidAnalysisResult(MeFuncPhase_DOMINANCE, &func);
-  m->InvalidAnalysisResult(MeFuncPhase_MELOOP, &func);
+  if (cfgChange) {
+    m->InvalidAnalysisResult(MeFuncPhase_DOMINANCE, &func);
+    m->InvalidAnalysisResult(MeFuncPhase_MELOOP, &func);
+  }
 }
 
 AnalysisResult *MeDoLoopCanon::Run(MeFunction *func, MeFuncResultMgr *m, ModuleResultMgr*) {
diff --git a/src/maple_util/include/profile.h b/src/maple_util/include/profile.h
index fce07def5bb5b4599405d4bbddf0309a55cc16fc..168d3eb71884c77bd656c5115fc313a84af08126 100644
--- a/src/maple_util/include/profile.h
+++ b/src/maple_util/include/profile.h
@@ -82,12 +82,12 @@ class Profile {
 
  private:
   bool valid = false;
-  bool initialized = false;
   bool profileMode = false;
   bool isCoreSo = false;
   bool isAppProfile = false;
   static bool debug;
   static uint32 hotFuncCountThreshold;
+  static bool initialized;
   std::vector<std::string> strMap;
   std::string dexName;
   std::string appPackageName;
diff --git a/src/maple_util/src/profile.cpp b/src/maple_util/src/profile.cpp
index 4d172e72d68c4883c3c127a9fa53dfd5e51f32db..3613f31223fab9b6470d6015c3be57362a9c9ce7 100644
--- a/src/maple_util/src/profile.cpp
+++ b/src/maple_util/src/profile.cpp
@@ -32,6 +32,7 @@ namespace maple {
 constexpr uint8 Profile::stringEnd = 0x00;
 uint32 Profile::hotFuncCountThreshold = 0;
 bool Profile::debug = false;
+bool Profile::initialized = false;
 constexpr uint32 kPrecision = 1000000;
 // preHot data
 const std::string Profile::preClassHot[] = {
@@ -259,6 +260,7 @@ void Profile::InitPreHot() {
 
 bool Profile::DeCompress(const std::string &path, const std::string &dexNameInner, ProfileType type) {
   if (initialized) {
+    LogInfo::MapleLogger() << "System server Profile has been decompressed before" << '\n';
     return valid;
   }
   initialized = true;
diff --git a/src/mpl2mpl/src/muid_replacement.cpp b/src/mpl2mpl/src/muid_replacement.cpp
index c552df28dda97af89e955026e8d12987a755410b..fe913340e3b63d51bad83bb595774dc8aacde0f6 100644
--- a/src/mpl2mpl/src/muid_replacement.cpp
+++ b/src/mpl2mpl/src/muid_replacement.cpp
@@ -75,8 +75,9 @@ ConstvalNode* MUIDReplacement::GetConstvalNode(int64 index) {
 void MUIDReplacement::DumpMUIDFile(bool isFunc) {
   std::ofstream outFile;
   const std::string &mplName = GetMIRModule().GetFileName();
-  CHECK_FATAL(mplName.rfind(".mpl") != std::string::npos, "can not find .mpl");
-  std::string prefix = mplName.substr(0, mplName.rfind(".mpl"));
+  size_t index = mplName.rfind(".");
+  CHECK_FATAL(index != std::string::npos, "can not find src file");
+  std::string prefix = mplName.substr(0, index);
   std::string outFileName;
   if (isFunc) {
     outFileName = prefix + ".func.muid";
diff --git a/src/mplfe/BUILD.gn b/src/mplfe/BUILD.gn
index 7bb822e155d58b3f986b09b396021b176669c517..bc9ab83e8c234674f89c655fb4ad60da7e98d922 100644
--- a/src/mplfe/BUILD.gn
+++ b/src/mplfe/BUILD.gn
@@ -13,6 +13,9 @@
 # See the Mulan PSL v1 for more details.
 #
 configs = [ "${MAPLEALL_ROOT}:mapleallcompilecfg" ]
+if (COV_CHECK == 1) {
+  cflags = [ "-DENABLE_COV_CHECK=1" ]
+}
 
 include_directories = [
   "${MPLFE_ROOT}/common/include",
@@ -38,13 +41,13 @@ static_library("lib_mplfe_util") {
     "${MPLFE_ROOT}/common/src/fe_function.cpp",
     "${MPLFE_ROOT}/common/src/fe_function_phase_result.cpp",
     "${MPLFE_ROOT}/common/src/fe_input_helper.cpp",
+    "${MPLFE_ROOT}/common/src/fe_java_string_manager.cpp",
     "${MPLFE_ROOT}/common/src/fe_manager.cpp",
     "${MPLFE_ROOT}/common/src/fe_options.cpp",
-    "${MPLFE_ROOT}/common/src/fe_java_string_manager.cpp",
+    "${MPLFE_ROOT}/common/src/fe_struct_elem_info.cpp",
     "${MPLFE_ROOT}/common/src/fe_timer_ns.cpp",
     "${MPLFE_ROOT}/common/src/fe_type_hierarchy.cpp",
     "${MPLFE_ROOT}/common/src/fe_type_manager.cpp",
-    "${MPLFE_ROOT}/common/src/fe_struct_elem_info.cpp",
     "${MPLFE_ROOT}/common/src/fe_utils.cpp",
     "${MPLFE_ROOT}/common/src/fe_utils_java.cpp",
     "${MPLFE_ROOT}/common/src/feir_builder.cpp",
@@ -87,9 +90,9 @@ executable("mplfe") {
     ":lib_mplfe_jbc_input",
     ":lib_mplfe_util",
     "${MAPLEALL_ROOT}/huawei_secure_c:libHWSecureC",
+    "${MAPLEALL_ROOT}/maple_driver:libdriver_option",
     "${MAPLEALL_ROOT}/maple_ir:libmplir",
     "${MAPLEALL_ROOT}/mpl2mpl:libmpl2mpl",
-    "${MAPLEALL_ROOT}/maple_driver:libdriver_option",
   ]
   libs = [
     "${OPENSOURCE_DEPS}/libmempool.a",
diff --git a/src/mplfe/test/BUILD.gn b/src/mplfe/test/BUILD.gn
new file mode 100644
index 0000000000000000000000000000000000000000..68730fee04a514de1b57e8e95149fcd0dc9191b3
--- /dev/null
+++ b/src/mplfe/test/BUILD.gn
@@ -0,0 +1,91 @@
+#
+# Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under the Mulan PSL v1.
+# You can use this software according to the terms and conditions of the Mulan PSL v1.
+# You may obtain a copy of Mulan PSL v1 at:
+#
+#     http://license.coscl.org.cn/MulanPSL
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v1 for more details.
+#
+configs = [ "${MAPLEALL_ROOT}:mapleallcompilecfg" ]
+cflags += [
+  "-fprofile-arcs",
+  "-ftest-coverage",
+  "-DMIR_FEATURE_FULL=1",
+  "-DMPLFE_FULL_INFO_DUMP=1",
+  "-DENABLE_COV_CHECK=1",
+]
+
+include_directories = [
+  "${MPLFE_ROOT}/common/include",
+  "${MPLFE_ROOT}/jbc_input/include",
+  "${MAPLEALL_ROOT}/huawei_secure_c/include",
+  "${MAPLEALL_ROOT}/maple_ir/include",
+  "${MAPLEALL_ROOT}/maple_util/include",
+  "${MAPLEALL_ROOT}/maple_driver/include",
+  "${MAPLEALL_ROOT}/mempool/include",
+  "${MAPLE_ROOT}/build/prebuilt/gtestlib/include",
+]
+
+executable("mplfeUT") {
+  sources = [
+    "${MPLFE_ROOT}/test/base64_test.cpp",
+    "${MPLFE_ROOT}/test/basic_io_test.cpp",
+    "${MPLFE_ROOT}/test/fe_algorithm_test.cpp",
+    "${MPLFE_ROOT}/test/fe_file_ops_test.cpp",
+    "${MPLFE_ROOT}/test/fe_file_type_test.cpp",
+    "${MPLFE_ROOT}/test/fe_function_test.cpp",
+    "${MPLFE_ROOT}/test/fe_struct_elem_info_test.cpp",
+    "${MPLFE_ROOT}/test/fe_type_hierarchy_test.cpp",
+    "${MPLFE_ROOT}/test/fe_type_manager_test.cpp",
+    "${MPLFE_ROOT}/test/fe_utils_test.cpp",
+    "${MPLFE_ROOT}/test/feir_builder_test.cpp",
+    "${MPLFE_ROOT}/test/feir_stmt_dfg_test.cpp",
+    "${MPLFE_ROOT}/test/feir_stmt_test.cpp",
+    "${MPLFE_ROOT}/test/feir_test_base.cpp",
+    "${MPLFE_ROOT}/test/feir_type_helper_test.cpp",
+    "${MPLFE_ROOT}/test/feir_type_test.cpp",
+    "${MPLFE_ROOT}/test/feir_var_test.cpp",
+    "${MPLFE_ROOT}/test/jbc_class2fe_helper_test.cpp",
+    "${MPLFE_ROOT}/test/jbc_class_const_test.cpp",
+    "${MPLFE_ROOT}/test/jbc_class_test.cpp",
+    "${MPLFE_ROOT}/test/jbc_function_test.cpp",
+    "${MPLFE_ROOT}/test/jbc_opcode_helper_test.cpp",
+    "${MPLFE_ROOT}/test/jbc_stack2fe_helper_test.cpp",
+    "${MPLFE_ROOT}/test/jbc_stack_helper_test.cpp",
+    "${MPLFE_ROOT}/test/jbc_util_test.cpp",
+    "${MPLFE_ROOT}/test/mplfeUT.cpp",
+    "${MPLFE_ROOT}/test/mplfe_ut_options.cpp",
+    "${MPLFE_ROOT}/test/mplfe_ut_regx.cpp",
+    "${MPLFE_ROOT}/test/mplfe_ut_regx_test.cpp",
+  ]
+  include_dirs = include_directories
+  deps = [
+    "${MAPLEALL_ROOT}/huawei_secure_c:libHWSecureC",
+    "${MAPLEALL_ROOT}/maple_ir:libmplir",
+    "${MAPLEALL_ROOT}/mpl2mpl:libmpl2mpl",
+    "${MPLFE_ROOT}:lib_mplfe_jbc_input",
+    "${MPLFE_ROOT}:lib_mplfe_util",
+  ]
+  libs = [
+    "${OPENSOURCE_DEPS}/libmempool.a",
+    "${OPENSOURCE_DEPS}/libmplutil.a",
+    "${MAPLE_ROOT}/build/prebuilt/gtestlib/lib/libgmock.so",
+    "${MAPLE_ROOT}/build/prebuilt/gtestlib/lib/libgmock_main.so",
+    "${MAPLE_ROOT}/build/prebuilt/gtestlib/lib/libgtest.so",
+    "${MAPLE_ROOT}/build/prebuilt/gtestlib/lib/libgtest_main.so",
+    "z",
+    "pthread",
+  ]
+  ldflags = [
+    "-fprofile-arcs",
+    "-ftest-coverage",
+    "-Wno-defaulted-function-deleted",
+    "-Wl,-rpath,${MAPLE_ROOT}/build/prebuilt/gtestlib/lib",
+  ]
+}
diff --git a/src/mplfe/test/base64_test.cpp b/src/mplfe/test/base64_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..29c866c3ad200d600f3b43948df76bc3dd807b37
--- /dev/null
+++ b/src/mplfe/test/base64_test.cpp
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v1 for more details.
+ */
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+#include "base64.h"
+
+namespace maple {
+TEST(Base64, Encode) {
+  uint8 buf[] = { 'A', 'B', 'C', 'D' };
+  std::string base64Str = Base64::Encode(buf, 4);
+  EXPECT_EQ(base64Str, "QUJDRA==");
+}
+
+TEST(Base64, Decode) {
+  std::string base64Str = "QUJDRA==";
+  size_t length = 0;
+  uint8 *buf = Base64::Decode(base64Str, length);
+  ASSERT_EQ(length, 4);
+  EXPECT_EQ(buf[0], 'A');
+  EXPECT_EQ(buf[1], 'B');
+  EXPECT_EQ(buf[2], 'C');
+  EXPECT_EQ(buf[3], 'D');
+}
+
+TEST(Base64, Decode_Boundary1) {
+  std::string base64Str = "";
+  size_t length = 0;
+  (void)Base64::Decode(base64Str, length);
+  ASSERT_EQ(length, 0);
+}
+
+TEST(Base64, Decode_Boundary2) {
+  std::string base64Str = "QUI=";
+  size_t length = 0;
+  uint8 *buf = Base64::Decode(base64Str, length);
+  ASSERT_EQ(length, 2);
+  EXPECT_EQ(buf[0], 'A');
+  EXPECT_EQ(buf[1], 'B');
+}
+}  // namespace maple
\ No newline at end of file
diff --git a/src/mplfe/test/basic_io_test.cpp b/src/mplfe/test/basic_io_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..fef5d811170ef533ed59fedc3c3c8dd873a7d1b4
--- /dev/null
+++ b/src/mplfe/test/basic_io_test.cpp
@@ -0,0 +1,314 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v1 for more details.
+ */
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+#include "basic_io.h"
+#include "base64.h"
+
+namespace maple {
+TEST(BasicIOMapFile, GenFileInMemory) {
+  uint8 buf[] = { 0x00, 0x01, 0x02, 0x03 };
+  std::unique_ptr<BasicIOMapFile> mapFile = BasicIOMapFile::GenFileInMemory("test", buf, sizeof(buf));
+  EXPECT_NE(mapFile.get(), nullptr);
+  EXPECT_EQ(mapFile->GetLength(), 4);
+}
+
+class BasicIOReadTest : public testing::Test {
+ public:
+  BasicIOReadTest() {
+    testFile1 = BasicIOMapFile::GenFileInMemory("test", buf1, sizeof(buf1));
+    testFile2 = BasicIOMapFile::GenFileInMemory("test", buf2, sizeof(buf2));
+    testFile3 = BasicIOMapFile::GenFileInMemory("test", buf3, sizeof(buf3));
+    testFile4 = BasicIOMapFile::GenFileInMemory("test", buf4, sizeof(buf4));
+    testFile5 = BasicIOMapFile::GenFileInMemory("test", buf5, sizeof(buf5));
+  }
+
+  ~BasicIOReadTest() = default;
+
+  BasicIOMapFile &GetTestFile1() {
+    CHECK_NULL_FATAL(testFile1.get());
+    return *testFile1;
+  }
+
+  BasicIOMapFile &GetTestFile2() {
+    CHECK_NULL_FATAL(testFile2.get());
+    return *testFile2;
+  }
+
+  BasicIOMapFile &GetTestFile3() {
+    CHECK_NULL_FATAL(testFile3.get());
+    return *testFile3;
+  }
+
+  BasicIOMapFile &GetTestFile4() {
+    CHECK_NULL_FATAL(testFile4.get());
+    return *testFile4;
+  }
+
+  BasicIOMapFile &GetTestFile5() {
+    CHECK_NULL_FATAL(testFile5.get());
+    return *testFile5;
+  }
+
+ private:
+  std::unique_ptr<BasicIOMapFile> testFile1;
+  std::unique_ptr<BasicIOMapFile> testFile2;
+  std::unique_ptr<BasicIOMapFile> testFile3;
+  std::unique_ptr<BasicIOMapFile> testFile4;
+  std::unique_ptr<BasicIOMapFile> testFile5;
+  uint8 buf1[16] = {0x01, 0xFF, 0x02, 0xFE, 0x03, 0xFD, 0x04, 0xFC, 0x05, 0xFB, 0x06, 0xFA, 0x07, 0xF8, 0x08, 0xF7};
+  uint8 buf2[12] = {0x3F, 0x80, 0x00, 0x00, 0xBF, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
+  uint8 buf3[12] = {0x00, 0x00, 0x80, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0xBF};
+  uint8 buf4[4] = {'A', 'B', 'C', 'D'};
+  uint8 buf5[1] = {0x00};
+};
+
+TEST_F(BasicIOReadTest, ReadUInt8) {
+  BasicIORead ioBigEndian(GetTestFile1(), true);
+  BasicIORead ioLittleEndian(GetTestFile1(), false);
+  bool success = false;
+  EXPECT_EQ(ioBigEndian.ReadUInt8(), 0x01);
+  EXPECT_EQ(ioLittleEndian.ReadUInt8(), 0x01);
+  EXPECT_EQ(ioBigEndian.ReadUInt8(success), 0xFF);
+  EXPECT_EQ(success, true);
+  EXPECT_EQ(ioLittleEndian.ReadUInt8(success), 0xFF);
+  EXPECT_EQ(success, true);
+}
+
+TEST_F(BasicIOReadTest, ReadInt8) {
+  BasicIORead ioBigEndian(GetTestFile1(), true);
+  BasicIORead ioLittleEndian(GetTestFile1(), false);
+  bool success = false;
+  EXPECT_EQ(ioBigEndian.ReadInt8(), static_cast<int8>(0x01));
+  EXPECT_EQ(ioLittleEndian.ReadInt8(), static_cast<int8>(0x01));
+  EXPECT_EQ(ioBigEndian.ReadInt8(success), static_cast<int8>(0xFF));
+  EXPECT_EQ(success, true);
+  EXPECT_EQ(ioLittleEndian.ReadInt8(success), static_cast<int8>(0xFF));
+  EXPECT_EQ(success, true);
+}
+
+TEST_F(BasicIOReadTest, ReadUInt16) {
+  BasicIORead ioBigEndian(GetTestFile1(), true);
+  BasicIORead ioLittleEndian(GetTestFile1(), false);
+  bool success = false;
+  EXPECT_EQ(ioBigEndian.ReadUInt16(), 0x01FF);
+  EXPECT_EQ(ioLittleEndian.ReadUInt16(), 0xFF01);
+  EXPECT_EQ(ioBigEndian.ReadUInt16(success), 0x02FE);
+  EXPECT_EQ(success, true);
+  EXPECT_EQ(ioLittleEndian.ReadUInt16(success), 0xFE02);
+  EXPECT_EQ(success, true);
+}
+
+TEST_F(BasicIOReadTest, ReadInt16) {
+  BasicIORead ioBigEndian(GetTestFile1(), true);
+  BasicIORead ioLittleEndian(GetTestFile1(), false);
+  bool success = false;
+  EXPECT_EQ(ioBigEndian.ReadInt16(), static_cast<int16>(0x01FF));
+  EXPECT_EQ(ioLittleEndian.ReadInt16(), static_cast<int16>(0xFF01));
+  EXPECT_EQ(ioBigEndian.ReadInt16(success), static_cast<int16>(0x02FE));
+  EXPECT_EQ(success, true);
+  EXPECT_EQ(ioLittleEndian.ReadInt16(success), static_cast<int16>(0xFE02));
+  EXPECT_EQ(success, true);
+}
+
+TEST_F(BasicIOReadTest, ReadUInt32) {
+  BasicIORead ioBigEndian(GetTestFile1(), true);
+  BasicIORead ioLittleEndian(GetTestFile1(), false);
+  bool success = false;
+  EXPECT_EQ(ioBigEndian.ReadUInt32(), 0x01FF02FE);
+  EXPECT_EQ(ioLittleEndian.ReadUInt32(), 0xFE02FF01);
+  EXPECT_EQ(ioBigEndian.ReadUInt32(success), 0x03FD04FC);
+  EXPECT_EQ(success, true);
+  EXPECT_EQ(ioLittleEndian.ReadUInt32(success), 0xFC04FD03);
+  EXPECT_EQ(success, true);
+}
+
+TEST_F(BasicIOReadTest, ReadInt32) {
+  BasicIORead ioBigEndian(GetTestFile1(), true);
+  BasicIORead ioLittleEndian(GetTestFile1(), false);
+  bool success = false;
+  EXPECT_EQ(ioBigEndian.ReadInt32(), static_cast<int32>(0x01FF02FE));
+  EXPECT_EQ(ioLittleEndian.ReadInt32(), static_cast<int32>(0xFE02FF01));
+  EXPECT_EQ(ioBigEndian.ReadInt32(success), static_cast<int32>(0x03FD04FC));
+  EXPECT_EQ(success, true);
+  EXPECT_EQ(ioLittleEndian.ReadInt32(success), static_cast<int32>(0xFC04FD03));
+  EXPECT_EQ(success, true);
+}
+
+TEST_F(BasicIOReadTest, ReadUInt64) {
+  BasicIORead ioBigEndian(GetTestFile1(), true);
+  BasicIORead ioLittleEndian(GetTestFile1(), false);
+  bool success = false;
+  EXPECT_EQ(ioBigEndian.ReadUInt64(), 0x01FF02FE03FD04FC);
+  EXPECT_EQ(ioLittleEndian.ReadUInt64(), 0xFC04FD03FE02FF01);
+  EXPECT_EQ(ioBigEndian.ReadUInt64(success), 0x05FB06FA07F808F7);
+  EXPECT_EQ(success, true);
+  EXPECT_EQ(ioLittleEndian.ReadUInt64(success), 0xF708F807FA06FB05);
+  EXPECT_EQ(success, true);
+}
+
+TEST_F(BasicIOReadTest, ReadInt64) {
+  BasicIORead ioBigEndian(GetTestFile1(), true);
+  BasicIORead ioLittleEndian(GetTestFile1(), false);
+  bool success = false;
+  EXPECT_EQ(ioBigEndian.ReadInt64(), static_cast<int64>(0x01FF02FE03FD04FC));
+  EXPECT_EQ(ioLittleEndian.ReadInt64(), static_cast<int64>(0xFC04FD03FE02FF01));
+  EXPECT_EQ(ioBigEndian.ReadInt64(success), static_cast<int64>(0x05FB06FA07F808F7));
+  EXPECT_EQ(success, true);
+  EXPECT_EQ(ioLittleEndian.ReadInt64(success), static_cast<int64>(0xF708F807FA06FB05));
+  EXPECT_EQ(success, true);
+}
+
+TEST_F(BasicIOReadTest, ReadFloat) {
+  BasicIORead ioBigEndian(GetTestFile2(), true);
+  BasicIORead ioLittleEndian(GetTestFile3(), false);
+  EXPECT_EQ(ioBigEndian.ReadFloat(), 1.0f);
+  EXPECT_EQ(ioLittleEndian.ReadFloat(), 1.0f);
+  EXPECT_EQ(ioBigEndian.ReadDouble(), -1.0);
+  EXPECT_EQ(ioLittleEndian.ReadDouble(), -1.0);
+}
+
+TEST_F(BasicIOReadTest, ReadFloat2) {
+  BasicIORead ioBigEndian(GetTestFile2(), true);
+  BasicIORead ioLittleEndian(GetTestFile3(), false);
+  bool success = false;
+  EXPECT_EQ(ioBigEndian.ReadFloat(success), 1.0f);
+  EXPECT_EQ(success, true);
+  EXPECT_EQ(ioLittleEndian.ReadFloat(success), 1.0f);
+  EXPECT_EQ(success, true);
+  EXPECT_EQ(ioBigEndian.ReadDouble(success), -1.0);
+  EXPECT_EQ(success, true);
+  EXPECT_EQ(ioLittleEndian.ReadDouble(success), -1.0);
+  EXPECT_EQ(success, true);
+}
+
+TEST_F(BasicIOReadTest, ReadBufferUInt8) {
+  BasicIORead ioBigEndian(GetTestFile4(), true);
+  BasicIORead ioLittleEndian(GetTestFile4(), false);
+  bool success = false;
+  uint8 buf[2];
+  // big endian
+  ioBigEndian.ReadBufferUInt8(buf, 2);
+  EXPECT_EQ(buf[0], static_cast<uint8>('A'));
+  EXPECT_EQ(buf[1], static_cast<uint8>('B'));
+  ioBigEndian.ReadBufferUInt8(buf, 2, success);
+  EXPECT_EQ(success, true);
+  EXPECT_EQ(buf[0], static_cast<uint8>('C'));
+  EXPECT_EQ(buf[1], static_cast<uint8>('D'));
+  ioBigEndian.ReadBufferUInt8(buf, 2, success);
+  EXPECT_EQ(success, false);
+  // little endian
+  ioLittleEndian.ReadBufferUInt8(buf, 2);
+  EXPECT_EQ(buf[0], static_cast<uint8>('A'));
+  EXPECT_EQ(buf[1], static_cast<uint8>('B'));
+  ioLittleEndian.ReadBufferUInt8(buf, 2, success);
+  EXPECT_EQ(success, true);
+  EXPECT_EQ(buf[0], static_cast<uint8>('C'));
+  EXPECT_EQ(buf[1], static_cast<uint8>('D'));
+  ioLittleEndian.ReadBufferUInt8(buf, 2, success);
+  EXPECT_EQ(success, false);
+}
+
+TEST_F(BasicIOReadTest, ReadBufferInt8) {
+  BasicIORead ioBigEndian(GetTestFile4(), true);
+  BasicIORead ioLittleEndian(GetTestFile4(), false);
+  bool success = false;
+  int8 buf[2];
+  // big endian
+  ioBigEndian.ReadBufferInt8(buf, 2);
+  EXPECT_EQ(buf[0], static_cast<int8>('A'));
+  EXPECT_EQ(buf[1], static_cast<int8>('B'));
+  ioBigEndian.ReadBufferInt8(buf, 2, success);
+  EXPECT_EQ(success, true);
+  EXPECT_EQ(buf[0], static_cast<int8>('C'));
+  EXPECT_EQ(buf[1], static_cast<int8>('D'));
+  ioBigEndian.ReadBufferInt8(buf, 2, success);
+  EXPECT_EQ(success, false);
+  // little endian
+  ioLittleEndian.ReadBufferInt8(buf, 2);
+  EXPECT_EQ(buf[0], static_cast<int8>('A'));
+  EXPECT_EQ(buf[1], static_cast<int8>('B'));
+  ioLittleEndian.ReadBufferInt8(buf, 2, success);
+  EXPECT_EQ(success, true);
+  EXPECT_EQ(buf[0], static_cast<int8>('C'));
+  EXPECT_EQ(buf[1], static_cast<int8>('D'));
+  ioLittleEndian.ReadBufferInt8(buf, 2, success);
+  EXPECT_EQ(success, false);
+}
+
+TEST_F(BasicIOReadTest, ReadBufferChar) {
+  BasicIORead ioBigEndian(GetTestFile4(), true);
+  BasicIORead ioLittleEndian(GetTestFile4(), false);
+  bool success = false;
+  char buf[2];
+  // big endian
+  ioBigEndian.ReadBufferChar(buf, 2);
+  EXPECT_EQ(buf[0], 'A');
+  EXPECT_EQ(buf[1], 'B');
+  ioBigEndian.ReadBufferChar(buf, 2, success);
+  EXPECT_EQ(success, true);
+  EXPECT_EQ(buf[0], 'C');
+  EXPECT_EQ(buf[1], 'D');
+  ioBigEndian.ReadBufferChar(buf, 2, success);
+  EXPECT_EQ(success, false);
+  // little endian
+  ioLittleEndian.ReadBufferChar(buf, 2);
+  EXPECT_EQ(buf[0], 'A');
+  EXPECT_EQ(buf[1], 'B');
+  ioLittleEndian.ReadBufferChar(buf, 2, success);
+  EXPECT_EQ(success, true);
+  EXPECT_EQ(buf[0], 'C');
+  EXPECT_EQ(buf[1], 'D');
+  ioLittleEndian.ReadBufferChar(buf, 2, success);
+  EXPECT_EQ(success, false);
+}
+
+TEST_F(BasicIOReadTest, ReadString) {
+  BasicIORead ioBigEndian(GetTestFile4(), true);
+  BasicIORead ioLittleEndian(GetTestFile4(), false);
+  bool success = false;
+  // big endian
+  EXPECT_EQ(ioBigEndian.ReadString(2), "AB");
+  EXPECT_EQ(ioBigEndian.ReadString(2, success), "CD");
+  EXPECT_EQ(success, true);
+  EXPECT_EQ(ioBigEndian.ReadString(2, success), "");
+  EXPECT_EQ(success, false);
+  // little endian
+  EXPECT_EQ(ioLittleEndian.ReadString(2), "AB");
+  EXPECT_EQ(ioLittleEndian.ReadString(2, success), "CD");
+  EXPECT_EQ(success, true);
+  EXPECT_EQ(ioLittleEndian.ReadString(2, success), "");
+  EXPECT_EQ(success, false);
+}
+
+TEST_F(BasicIOReadTest, Read_BoundaryCheck) {
+  BasicIORead ioBigEndian(GetTestFile5(), true);
+  ioBigEndian.ReadUInt8();
+  bool success = false;
+  ioBigEndian.ReadUInt8(success);
+  EXPECT_EQ(success, false);
+  ioBigEndian.ReadUInt16(success);
+  EXPECT_EQ(success, false);
+  ioBigEndian.ReadUInt32(success);
+  EXPECT_EQ(success, false);
+  ioBigEndian.ReadUInt64(success);
+  EXPECT_EQ(success, false);
+  ioBigEndian.ReadFloat(success);
+  EXPECT_EQ(success, false);
+  ioBigEndian.ReadDouble(success);
+  EXPECT_EQ(success, false);
+}
+
+}  // namespace maple
\ No newline at end of file
diff --git a/src/mplfe/test/fe_algorithm_test.cpp b/src/mplfe/test/fe_algorithm_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..da62e1b1542fa496009411f9ae5452a1a50ddcc5
--- /dev/null
+++ b/src/mplfe/test/fe_algorithm_test.cpp
@@ -0,0 +1,226 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v1 for more details.
+ */
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+#include <set>
+#include <memory>
+#include <iostream>
+#include "fe_options.h"
+#include "fe_algorithm.h"
+#include "mpl_logging.h"
+
+namespace maple {
+class TestNode {
+ public:
+  TestNode(int argID, std::set<int> argItems) : id(argID) {
+    for (int item : argItems) {
+      items.insert(item);
+    }
+    mergeEnd = items.size() > 0;
+  }
+  ~TestNode() = default;
+
+  bool Merge(const TestNode &src) {
+    for (int item : src.GetItems()) {
+      items.insert(item);
+    }
+    return true;
+  }
+
+  bool MergeEnd() const {
+    return mergeEnd;
+  }
+
+  bool CheckExist(int item) const {
+    return items.find(item) != items.end();
+  }
+
+  bool CheckExist(std::set<int> argItems) const {
+    for (int item : argItems) {
+      if (items.find(item) == items.end()) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  const std::set<int> &GetItems() const {
+    return items;
+  }
+
+  int GetID() const {
+    return id;
+  }
+
+ private:
+  int id;
+  bool mergeEnd;
+  std::set<int> items;
+};  // class TestNode
+
+class CorrelativeMergeTest {
+ public:
+  CorrelativeMergeTest() = default;
+  ~CorrelativeMergeTest() = default;
+};
+
+// Test1
+TEST(CorrelativeMergeTest, Test1) {
+  std::map<TestNode*, std::set<TestNode*>> correlation;
+  std::unique_ptr<TestNode> node0 = std::make_unique<TestNode>(0, std::set<int>({ 0 }));
+  std::unique_ptr<TestNode> node1 = std::make_unique<TestNode>(1, std::set<int>());
+  correlation[node1.get()].insert(node0.get());
+  CorrelativeMerge<TestNode> mergeHelper(correlation, &TestNode::Merge, &TestNode::MergeEnd);
+  mergeHelper.ProcessAll();
+  EXPECT_EQ(node1->CheckExist(0), true);
+}
+
+// Test2
+// Graph: doc/images/ut_cases/CorrelativeMerge/Test2.dot
+// Image: doc/images/ut_cases/CorrelativeMerge/Test2.png
+TEST(CorrelativeMergeTest, Test2) {
+  std::map<TestNode*, std::set<TestNode*>> correlation;
+  std::unique_ptr<TestNode> node0 = std::make_unique<TestNode>(0, std::set<int>({ 0 }));
+  std::unique_ptr<TestNode> node1 = std::make_unique<TestNode>(1, std::set<int>());
+  std::unique_ptr<TestNode> node2 = std::make_unique<TestNode>(2, std::set<int>());
+  correlation[node1.get()].insert(node0.get());
+  correlation[node1.get()].insert(node2.get());
+  correlation[node2.get()].insert(node1.get());
+  CorrelativeMerge<TestNode> mergeHelper(correlation, &TestNode::Merge, &TestNode::MergeEnd);
+  mergeHelper.ProcessAll();
+  EXPECT_EQ(node1->CheckExist(0), true);
+  EXPECT_EQ(node2->CheckExist(0), true);
+  INFO(kLncInfo, "Visit Count = %d", mergeHelper.GetVisitCount());
+}
+
+// Test3
+// Graph: doc/images/ut_cases/CorrelativeMerge/Test3.dot
+// Image: doc/images/ut_cases/CorrelativeMerge/Test3.png
+TEST(CorrelativeMergeTest, Test3) {
+  std::map<TestNode*, std::set<TestNode*>> correlation;
+  std::unique_ptr<TestNode> node0 = std::make_unique<TestNode>(0, std::set<int>({ 0 }));
+  std::unique_ptr<TestNode> node1 = std::make_unique<TestNode>(1, std::set<int>());
+  std::unique_ptr<TestNode> node2 = std::make_unique<TestNode>(2, std::set<int>({ 2 }));
+  correlation[node1.get()].insert(node0.get());
+  correlation[node1.get()].insert(node2.get());
+  correlation[node2.get()].insert(node1.get());
+  CorrelativeMerge<TestNode> mergeHelper(correlation, &TestNode::Merge, &TestNode::MergeEnd);
+  mergeHelper.ProcessAll();
+  EXPECT_EQ(node1->CheckExist(std::set<int>({ 0, 2 })), true);
+  INFO(kLncInfo, "Visit Count = %d", mergeHelper.GetVisitCount());
+}
+
+// Test4
+// Graph: doc/images/ut_cases/CorrelativeMerge/Test4.dot
+// Image: doc/images/ut_cases/CorrelativeMerge/Test4.png
+TEST(CorrelativeMergeTest, Test4) {
+  std::map<TestNode*, std::set<TestNode*>> correlation;
+  std::unique_ptr<TestNode> node0 = std::make_unique<TestNode>(0, std::set<int>({ 0 }));
+  std::unique_ptr<TestNode> node1 = std::make_unique<TestNode>(1, std::set<int>());
+  std::unique_ptr<TestNode> node2 = std::make_unique<TestNode>(2, std::set<int>());
+  std::unique_ptr<TestNode> node3 = std::make_unique<TestNode>(3, std::set<int>());
+  std::unique_ptr<TestNode> node4 = std::make_unique<TestNode>(4, std::set<int>());
+  std::unique_ptr<TestNode> node5 = std::make_unique<TestNode>(5, std::set<int>());
+  correlation[node1.get()].insert(node0.get());
+  correlation[node2.get()].insert(node1.get());
+  correlation[node2.get()].insert(node5.get());
+  correlation[node3.get()].insert(node2.get());
+  correlation[node4.get()].insert(node3.get());
+  correlation[node5.get()].insert(node4.get());
+  CorrelativeMerge<TestNode> mergeHelper(correlation, &TestNode::Merge, &TestNode::MergeEnd);
+  mergeHelper.ProcessAll();
+  EXPECT_EQ(node1->CheckExist(0), true);
+  EXPECT_EQ(node2->CheckExist(0), true);
+  EXPECT_EQ(node3->CheckExist(0), true);
+  EXPECT_EQ(node4->CheckExist(0), true);
+  EXPECT_EQ(node5->CheckExist(0), true);
+  INFO(kLncInfo, "Visit Count = %d", mergeHelper.GetVisitCount());
+}
+
+// Test5
+// Graph: doc/images/ut_cases/CorrelativeMerge/Test5.dot
+// Image: doc/images/ut_cases/CorrelativeMerge/Test5.png
+TEST(CorrelativeMergeTest, Test5) {
+  std::map<TestNode*, std::set<TestNode*>> correlation;
+  std::unique_ptr<TestNode> node0 = std::make_unique<TestNode>(0, std::set<int>({ 0 }));
+  std::unique_ptr<TestNode> node1 = std::make_unique<TestNode>(1, std::set<int>());
+  std::unique_ptr<TestNode> node2 = std::make_unique<TestNode>(2, std::set<int>());
+  std::unique_ptr<TestNode> node3 = std::make_unique<TestNode>(3, std::set<int>());
+  std::unique_ptr<TestNode> node4 = std::make_unique<TestNode>(4, std::set<int>({ 4 }));
+  std::unique_ptr<TestNode> node5 = std::make_unique<TestNode>(5, std::set<int>());
+  correlation[node1.get()].insert(node0.get());
+  correlation[node2.get()].insert(node1.get());
+  correlation[node2.get()].insert(node5.get());
+  correlation[node3.get()].insert(node2.get());
+  correlation[node4.get()].insert(node3.get());
+  correlation[node5.get()].insert(node4.get());
+  CorrelativeMerge<TestNode> mergeHelper(correlation, &TestNode::Merge, &TestNode::MergeEnd);
+  mergeHelper.ProcessAll();
+  EXPECT_EQ(node1->CheckExist(0), true);
+  EXPECT_EQ(node2->CheckExist(std::set<int>({ 0, 4 })), true);
+  EXPECT_EQ(node3->CheckExist(std::set<int>({ 0, 4 })), true);
+  EXPECT_EQ(node5->CheckExist(4), true);
+  INFO(kLncInfo, "Visit Count = %d", mergeHelper.GetVisitCount());
+}
+
+// Test6
+// Graph: doc/images/ut_cases/CorrelativeMerge/Test6.dot
+// Image: doc/images/ut_cases/CorrelativeMerge/Test6.png
+TEST(CorrelativeMergeTest, Test6) {
+  std::map<TestNode*, std::set<TestNode*>> correlation;
+  std::unique_ptr<TestNode> node0 = std::make_unique<TestNode>(0, std::set<int>({ 0 }));
+  std::unique_ptr<TestNode> node1 = std::make_unique<TestNode>(1, std::set<int>());
+  std::unique_ptr<TestNode> node2 = std::make_unique<TestNode>(2, std::set<int>({ 2 }));
+  std::unique_ptr<TestNode> node3 = std::make_unique<TestNode>(3, std::set<int>());
+  std::unique_ptr<TestNode> node4 = std::make_unique<TestNode>(4, std::set<int>());
+  correlation[node1.get()].insert(node0.get());
+  correlation[node2.get()].insert(node0.get());
+  correlation[node2.get()].insert(node4.get());
+  correlation[node3.get()].insert(node1.get());
+  correlation[node3.get()].insert(node2.get());
+  correlation[node4.get()].insert(node3.get());
+  CorrelativeMerge<TestNode> mergeHelper(correlation, &TestNode::Merge, &TestNode::MergeEnd);
+  mergeHelper.ProcessAll();
+  EXPECT_EQ(node1->CheckExist(0), true);
+  EXPECT_EQ(node3->CheckExist(std::set<int>({ 0, 2 })), true);
+  EXPECT_EQ(node4->CheckExist(std::set<int>({ 0, 2 })), true);
+  INFO(kLncInfo, "Visit Count = %d", mergeHelper.GetVisitCount());
+}
+
+// Test7
+// Graph: doc/images/ut_cases/CorrelativeMerge/Test7.dot
+// Image: doc/images/ut_cases/CorrelativeMerge/Test7.png
+TEST(CorrelativeMergeTest, Test7) {
+  std::map<TestNode*, std::set<TestNode*>> correlation;
+  std::unique_ptr<TestNode> node0 = std::make_unique<TestNode>(0, std::set<int>({ 0 }));
+  std::unique_ptr<TestNode> node1 = std::make_unique<TestNode>(1, std::set<int>());
+  std::unique_ptr<TestNode> node2 = std::make_unique<TestNode>(2, std::set<int>());
+  std::unique_ptr<TestNode> node3 = std::make_unique<TestNode>(3, std::set<int>());
+  std::unique_ptr<TestNode> node4 = std::make_unique<TestNode>(4, std::set<int>());
+  std::unique_ptr<TestNode> node5 = std::make_unique<TestNode>(5, std::set<int>());
+  correlation[node1.get()].insert(node0.get());
+  correlation[node1.get()].insert(node5.get());
+  correlation[node2.get()].insert(node1.get());
+  correlation[node3.get()].insert(node2.get());
+  correlation[node4.get()].insert(node2.get());
+  correlation[node5.get()].insert(node3.get());
+  correlation[node5.get()].insert(node4.get());
+  CorrelativeMerge<TestNode> mergeHelper(correlation, &TestNode::Merge, &TestNode::MergeEnd);
+  mergeHelper.LoopCheckAll();
+  mergeHelper.ProcessOne(*node3, true);
+  EXPECT_EQ(node3->CheckExist(std::set<int>({ 0 })), true);
+  INFO(kLncInfo, "Visit Count = %d", mergeHelper.GetVisitCount());
+}
+}  // namespace MAPLE
\ No newline at end of file
diff --git a/src/mplfe/test/fe_file_ops_test.cpp b/src/mplfe/test/fe_file_ops_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d50d3acb1788eec27e864d99bc77fb2517343bea
--- /dev/null
+++ b/src/mplfe/test/fe_file_ops_test.cpp
@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v1 for more details.
+ */
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+#include "fe_file_ops.h"
+
+namespace maple {
+TEST(FEFileOps, GetFilePath) {
+  EXPECT_EQ(FEFileOps::GetFilePath("name"), "");
+  EXPECT_EQ(FEFileOps::GetFilePath("/name"), "/");
+  EXPECT_EQ(FEFileOps::GetFilePath("path/"), "path/");
+  EXPECT_EQ(FEFileOps::GetFilePath("path/name"), "path/");
+  EXPECT_EQ(FEFileOps::GetFilePath("/path/name"), "/path/");
+  EXPECT_EQ(FEFileOps::GetFilePath("../name"), "../");
+}
+
+TEST(FEFileOps, GetFileNameWithExt) {
+  EXPECT_EQ(FEFileOps::GetFileNameWithExt("name"), "name");
+  EXPECT_EQ(FEFileOps::GetFileNameWithExt("/name"), "name");
+  EXPECT_EQ(FEFileOps::GetFileNameWithExt("path/"), "");
+  EXPECT_EQ(FEFileOps::GetFileNameWithExt("path/name"), "name");
+  EXPECT_EQ(FEFileOps::GetFileNameWithExt("/path/name"), "name");
+  EXPECT_EQ(FEFileOps::GetFileNameWithExt("../name"), "name");
+}
+
+TEST(FEFileOps, GetFileName) {
+  EXPECT_EQ(FEFileOps::GetFileName("name.ext"), "name");
+  EXPECT_EQ(FEFileOps::GetFileName("name"), "name");
+  EXPECT_EQ(FEFileOps::GetFileName(".ext"), "");
+  EXPECT_EQ(FEFileOps::GetFileName("/name.ext"), "name");
+  EXPECT_EQ(FEFileOps::GetFileName("path/name.ext"), "name");
+}
+
+TEST(FEFileOps, GetFileExtName) {
+  EXPECT_EQ(FEFileOps::GetFileExtName("name.ext"), "ext");
+  EXPECT_EQ(FEFileOps::GetFileExtName("name"), "");
+  EXPECT_EQ(FEFileOps::GetFileExtName(".ext"), "ext");
+  EXPECT_EQ(FEFileOps::GetFileExtName("/name.ext"), "ext");
+  EXPECT_EQ(FEFileOps::GetFileExtName("path/name.ext"), "ext");
+}
+}  // namespace maple
\ No newline at end of file
diff --git a/src/mplfe/test/fe_file_type_test.cpp b/src/mplfe/test/fe_file_type_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..973ed72266d0227a79938516f52f9302cd088871
--- /dev/null
+++ b/src/mplfe/test/fe_file_type_test.cpp
@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v1 for more details.
+ */
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+#include "fe_file_type.h"
+
+namespace maple {
+TEST(FEFileType, GetFileTypeByExtName) {
+  EXPECT_EQ(FEFileType::GetInstance().GetFileTypeByExtName("jar"), FEFileType::FileType::kJar);
+  EXPECT_EQ(FEFileType::GetInstance().GetFileTypeByExtName("class"), FEFileType::FileType::kClass);
+  EXPECT_EQ(FEFileType::GetInstance().GetFileTypeByExtName(""), FEFileType::FileType::kUnknown);
+  EXPECT_EQ(FEFileType::GetInstance().GetFileTypeByExtName("txt"), FEFileType::FileType::kUnknown);
+}
+
+TEST(FEFileType, RegisterExtName_Warn) {
+  FEFileType::GetInstance().RegisterExtName(FEFileType::FileType::kJar, "");
+  FEFileType::GetInstance().RegisterExtName(FEFileType::FileType::kUnknown, "txt");
+}
+
+TEST(FEFileType, RegisterMagicNumber_Warn) {
+  FEFileType::GetInstance().RegisterMagicNumber(FEFileType::FileType::kJar, 0);
+  FEFileType::GetInstance().RegisterMagicNumber(FEFileType::FileType::kUnknown, 0x12345678);
+}
+
+TEST(FEFileType, GetExtName) {
+  EXPECT_EQ(FEFileType::GetExtName("test.jar"), "jar");
+  EXPECT_EQ(FEFileType::GetExtName("../test.jar"), "jar");
+  EXPECT_EQ(FEFileType::GetExtName("../path/test.jar"), "jar");
+  EXPECT_EQ(FEFileType::GetExtName("path/test.jar"), "jar");
+  EXPECT_EQ(FEFileType::GetExtName("path/test"), "");
+}
+}
diff --git a/src/mplfe/test/fe_function_process_schedular_test.cpp b/src/mplfe/test/fe_function_process_schedular_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..f6b6057ba6f2084cba717c53f4cdae307e56c2b3
--- /dev/null
+++ b/src/mplfe/test/fe_function_process_schedular_test.cpp
@@ -0,0 +1,256 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v1 for more details.
+ */
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+#include "mplfe_compiler_component.h"
+#include <list>
+#include <unistd.h>
+#include <memory>
+
+namespace maple {
+class FEFunctionChild : public FEFunction {
+ public:
+  FEFunctionChild(std::list<uint32> &argResult, uint32 argIdx)
+      : FEFunction(nullptr),
+        result(argResult),
+        idx(argIdx) {}
+  virtual ~FEFunctionChild() = default;
+  void Process() override {
+    usleep(rand() % 1000);
+  }
+  void EmitToMIR() override {
+    result.push_back(idx);
+  }
+  bool PreProcessTypeNameIdx() override {
+    return true;
+  }
+  void GenerateGeneralStmt(bool &success) override {}
+  void GenerateGeneralStmtFailCallBack() override {}
+  void GenerateGeneralDebugInfo() override {}
+  bool VerifyGeneral() override {
+    return true;
+  }
+  void VerifyGeneralFailCallBack() override {}
+  void EmitToFEIRStmt() override {}
+  void GenerateArgVarList() override {}
+  bool HasThis() override {
+    return false;
+  }
+
+ private:
+  std::list<uint32> &result;
+  uint32 idx;
+};  // class FEFunctionChild
+
+TEST(FEFunctionProcessSchedular, RunSingle) {
+  std::list<uint32> results;
+  std::unique_ptr<FEFunction> function = std::make_unique<FEFunctionChild>(results, 0);
+  std::unique_ptr<FEFunctionProcessTask> task = std::make_unique<FEFunctionProcessTask>(function.get());
+  task->Run();
+  task->Finish();
+  EXPECT_EQ(results.size(), 1);
+}
+
+TEST(FEFunctionProcessSchedular, RunDirect) {
+  std::list<std::unique_ptr<FEFunction>> functions;
+  std::list<std::unique_ptr<FEFunctionProcessTask>> tasks;
+  std::list<uint32> results;
+  FEFunctionProcessSchedular schedular("test schedular");
+  for (uint32 i = 0; i < 1000; i++) {
+    functions.push_back(std::make_unique<FEFunctionChild>(results, i));
+    tasks.push_back(std::make_unique<FEFunctionProcessTask>(functions.back().get()));
+  }
+  for (const std::unique_ptr<FEFunctionProcessTask> &task : tasks) {
+    task->Run();
+    task->Finish();
+  }
+  for (uint32 i = 0; i < 1000; i++) {
+    EXPECT_EQ(results.front(), i);
+    results.pop_front();
+  }
+}
+
+TEST(FEFunctionProcessSchedular, RunSerial) {
+  std::list<std::unique_ptr<FEFunction>> functions;
+  std::list<std::unique_ptr<FEFunctionProcessTask>> tasks;
+  std::list<uint32> results;
+  FEFunctionProcessSchedular schedular("test schedular");
+  for (uint32 i = 0; i < 1000; i++) {
+    functions.push_back(std::make_unique<FEFunctionChild>(results, i));
+    tasks.push_back(std::make_unique<FEFunctionProcessTask>(functions.back().get()));
+  }
+  for (const std::unique_ptr<FEFunctionProcessTask> &task : tasks) {
+    schedular.AddTask(task.get());
+  }
+  schedular.RunTask(1, true);
+  for (uint32 i = 0; i < 1000; i++) {
+    EXPECT_EQ(results.front(), i);
+    results.pop_front();
+  }
+}
+
+TEST(FEFunctionProcessSchedular, RunParallel2) {
+  std::list<std::unique_ptr<FEFunction>> functions;
+  std::list<std::unique_ptr<FEFunctionProcessTask>> tasks;
+  std::list<uint32> results;
+  FEFunctionProcessSchedular schedular("test schedular");
+  for (uint32 i = 0; i < 1000; i++) {
+    functions.push_back(std::make_unique<FEFunctionChild>(results, i));
+    tasks.push_back(std::make_unique<FEFunctionProcessTask>(functions.back().get()));
+  }
+  for (const std::unique_ptr<FEFunctionProcessTask> &task : tasks) {
+    schedular.AddTask(task.get());
+  }
+  schedular.RunTask(2, true);
+  for (uint32 i = 0; i < 1000; i++) {
+    EXPECT_EQ(results.front(), i);
+    results.pop_front();
+  }
+}
+
+TEST(FEFunctionProcessSchedular, RunParallel4) {
+  std::list<std::unique_ptr<FEFunction>> functions;
+  std::list<std::unique_ptr<FEFunctionProcessTask>> tasks;
+  std::list<uint32> results;
+  FEFunctionProcessSchedular schedular("test schedular");
+  for (uint32 i = 0; i < 1000; i++) {
+    functions.push_back(std::make_unique<FEFunctionChild>(results, i));
+    tasks.push_back(std::make_unique<FEFunctionProcessTask>(functions.back().get()));
+  }
+  for (const std::unique_ptr<FEFunctionProcessTask> &task : tasks) {
+    schedular.AddTask(task.get());
+  }
+  schedular.RunTask(4, true);
+  for (uint32 i = 0; i < 1000; i++) {
+    EXPECT_EQ(results.front(), i);
+    results.pop_front();
+  }
+}
+
+TEST(FEFunctionProcessSchedular, RunParallel8) {
+  std::list<std::unique_ptr<FEFunction>> functions;
+  std::list<std::unique_ptr<FEFunctionProcessTask>> tasks;
+  std::list<uint32> results;
+  FEFunctionProcessSchedular schedular("test schedular");
+  for (uint32 i = 0; i < 1000; i++) {
+    functions.push_back(std::make_unique<FEFunctionChild>(results, i));
+    tasks.push_back(std::make_unique<FEFunctionProcessTask>(functions.back().get()));
+  }
+  for (const std::unique_ptr<FEFunctionProcessTask> &task : tasks) {
+    schedular.AddTask(task.get());
+  }
+  schedular.RunTask(8, true);
+  for (uint32 i = 0; i < 1000; i++) {
+    EXPECT_EQ(results.front(), i);
+    results.pop_front();
+  }
+}
+
+TEST(FEFunctionProcessSchedular, RunParallel16) {
+  std::list<std::unique_ptr<FEFunction>> functions;
+  std::list<std::unique_ptr<FEFunctionProcessTask>> tasks;
+  std::list<uint32> results;
+  FEFunctionProcessSchedular schedular("test schedular");
+  for (uint32 i = 0; i < 1000; i++) {
+    functions.push_back(std::make_unique<FEFunctionChild>(results, i));
+    tasks.push_back(std::make_unique<FEFunctionProcessTask>(functions.back().get()));
+  }
+  for (const std::unique_ptr<FEFunctionProcessTask> &task : tasks) {
+    schedular.AddTask(task.get());
+  }
+  schedular.RunTask(16, true);
+  for (uint32 i = 0; i < 1000; i++) {
+    EXPECT_EQ(results.front(), i);
+    results.pop_front();
+  }
+}
+
+TEST(FEFunctionProcessSchedular, RunParallel32) {
+  std::list<std::unique_ptr<FEFunction>> functions;
+  std::list<std::unique_ptr<FEFunctionProcessTask>> tasks;
+  std::list<uint32> results;
+  FEFunctionProcessSchedular schedular("test schedular");
+  for (uint32 i = 0; i < 1000; i++) {
+    functions.push_back(std::make_unique<FEFunctionChild>(results, i));
+    tasks.push_back(std::make_unique<FEFunctionProcessTask>(functions.back().get()));
+  }
+  for (const std::unique_ptr<FEFunctionProcessTask> &task : tasks) {
+    schedular.AddTask(task.get());
+  }
+  schedular.RunTask(32, true);
+  for (uint32 i = 0; i < 1000; i++) {
+    EXPECT_EQ(results.front(), i);
+    results.pop_front();
+  }
+}
+
+TEST(FEFunctionProcessSchedular, RunParallel48) {
+  std::list<std::unique_ptr<FEFunction>> functions;
+  std::list<std::unique_ptr<FEFunctionProcessTask>> tasks;
+  std::list<uint32> results;
+  FEFunctionProcessSchedular schedular("test schedular");
+  for (uint32 i = 0; i < 1000; i++) {
+    functions.push_back(std::make_unique<FEFunctionChild>(results, i));
+    tasks.push_back(std::make_unique<FEFunctionProcessTask>(functions.back().get()));
+  }
+  for (const std::unique_ptr<FEFunctionProcessTask> &task : tasks) {
+    schedular.AddTask(task.get());
+  }
+  schedular.RunTask(48, true);
+  for (uint32 i = 0; i < 1000; i++) {
+    EXPECT_EQ(results.front(), i);
+    results.pop_front();
+  }
+}
+
+TEST(FEFunctionProcessSchedular, RunParallel64) {
+  std::list<std::unique_ptr<FEFunction>> functions;
+  std::list<std::unique_ptr<FEFunctionProcessTask>> tasks;
+  std::list<uint32> results;
+  FEFunctionProcessSchedular schedular("test schedular");
+  for (uint32 i = 0; i < 1000; i++) {
+    functions.push_back(std::make_unique<FEFunctionChild>(results, i));
+    tasks.push_back(std::make_unique<FEFunctionProcessTask>(functions.back().get()));
+  }
+  for (const std::unique_ptr<FEFunctionProcessTask> &task : tasks) {
+    schedular.AddTask(task.get());
+  }
+  schedular.RunTask(64, true);
+  for (uint32 i = 0; i < 1000; i++) {
+    EXPECT_EQ(results.front(), i);
+    results.pop_front();
+  }
+}
+
+TEST(FEFunctionProcessSchedular, RunParallel128) {
+  std::list<std::unique_ptr<FEFunction>> functions;
+  std::list<std::unique_ptr<FEFunctionProcessTask>> tasks;
+  std::list<uint32> results;
+  FEFunctionProcessSchedular schedular("test schedular");
+  schedular.Init();
+  for (uint32 i = 0; i < 1000; i++) {
+    functions.push_back(std::make_unique<FEFunctionChild>(results, i));
+    tasks.push_back(std::make_unique<FEFunctionProcessTask>(functions.back().get()));
+  }
+  for (const std::unique_ptr<FEFunctionProcessTask> &task : tasks) {
+    schedular.AddTask(task.get());
+  }
+  schedular.RunTask(128, true);
+  for (uint32 i = 0; i < 1000; i++) {
+    EXPECT_EQ(results.front(), i);
+    results.pop_front();
+  }
+}
+}  // namespace maple
\ No newline at end of file
diff --git a/src/mplfe/test/fe_function_test.cpp b/src/mplfe/test/fe_function_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..40810f26cadd6777907722cf0dd6d49b3b556c4f
--- /dev/null
+++ b/src/mplfe/test/fe_function_test.cpp
@@ -0,0 +1,355 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v1 for more details.
+ */
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+#include "fe_function.h"
+#include "redirect_buffer.h"
+#include "mplfe_ut_environment.h"
+
+namespace maple {
+class GeneralStmtAuxPre : public GeneralStmt {
+ public:
+  GeneralStmtAuxPre() {
+    isAuxPre = true;
+  }
+  ~GeneralStmtAuxPre() = default;
+};
+
+class GeneralStmtAuxPost : public GeneralStmt {
+ public:
+  GeneralStmtAuxPost() {
+    isAuxPost = true;
+  }
+  ~GeneralStmtAuxPost() = default;
+};
+
+class FEFunctionDemo : public FEFunction {
+ public:
+  FEFunctionDemo(MapleAllocator &allocator, MIRFunction &argMIRFunction)
+      : FEFunction(argMIRFunction, std::make_unique<FEFunctionPhaseResult>(true)),
+        mapIdxStmt(allocator.Adapter()) {}
+  ~FEFunctionDemo() = default;
+
+  bool PreProcessTypeNameIdx() override {
+    return false;
+  }
+
+  bool GenerateGeneralStmt(const std::string &phaseName) override {
+    return true;
+  }
+
+  void GenerateGeneralStmtFailCallBack() override {}
+  void GenerateGeneralDebugInfo() override {}
+  bool GenerateArgVarList(const std::string &phaseName) override {
+    return true;
+  }
+
+  bool HasThis() override {
+    return false;
+  }
+
+  bool VerifyGeneral() override {
+    return false;
+  }
+
+  void VerifyGeneralFailCallBack() override {}
+  bool EmitToFEIRStmt(const std::string &phaseName) override {
+    return true;
+  }
+
+  void LoadGenStmtDemo1();
+  void LoadGenStmtDemo2();
+  void LoadGenStmtDemo3();
+  void LoadGenStmtDemo4();
+  void LoadGenStmtDemo5();
+
+  GeneralStmt *GetStmtByIdx(uint32 idx) {
+    CHECK_FATAL(mapIdxStmt.find(idx) != mapIdxStmt.end(), "invalid idx");
+    return mapIdxStmt[idx];
+  }
+
+  template <typename T>
+  T *NewGenStmt(uint32 idx) {
+    // T *stmt = new T(0);
+    GeneralStmt *ptrStmt = RegisterGeneralStmt(std::make_unique<T>());
+    genStmtTail->InsertBefore(ptrStmt);
+    mapIdxStmt[idx] = ptrStmt;
+    return static_cast<T*>(ptrStmt);
+  }
+
+  template <typename T>
+  T *NewGenStmt(GeneralStmtKind genKind, uint32 idx) {
+    // T *stmt = new T(0);
+    GeneralStmt *ptrStmt = RegisterGeneralStmt(std::make_unique<T>(genKind));
+    genStmtTail->InsertBefore(ptrStmt);
+    mapIdxStmt[idx] = ptrStmt;
+    return static_cast<T*>(ptrStmt);
+  }
+
+ private:
+  MapleMap<uint32, GeneralStmt*> mapIdxStmt;
+};
+
+class FEFunctionTest : public testing::Test, public RedirectBuffer {
+ public:
+  static MemPool *mp;
+  MapleAllocator allocator;
+  MIRFunction func;
+  FEFunctionDemo demoFunc;
+  FEFunctionTest()
+      : allocator(mp),
+        func(&MPLFEUTEnvironment::GetMIRModule(), StIdx(0, 0)),
+        demoFunc(allocator, func) {}
+  ~FEFunctionTest() = default;
+
+  static void SetUpTestCase() {
+    mp = memPoolCtrler.NewMemPool("MemPool for FEFunctionTest");
+  }
+
+  static void TearDownTestCase() {
+    memPoolCtrler.DeleteMemPool(mp);
+    mp = nullptr;
+  }
+};
+MemPool *FEFunctionTest::mp = nullptr;
+
+/* GenStmtDemo1:BB
+ * 0   StmtHead
+ * 1   Stmt (fallthru = true)
+ * 2   Stmt (fallthru = false)
+ * 3   StmtTail
+ */
+void FEFunctionDemo::LoadGenStmtDemo1() {
+  Init();
+  mapIdxStmt.clear();
+  (void)NewGenStmt<GeneralStmt>(1);
+  GeneralStmt *stmt2 = NewGenStmt<GeneralStmt>(2);
+  stmt2->SetFallThru(false);
+}
+
+TEST_F(FEFunctionTest, GeneralBBBuildForBB) {
+  demoFunc.LoadGenStmtDemo1();
+  bool resultBB = demoFunc.BuildGeneralBB("build Demo1 bb");
+  ASSERT_EQ(resultBB, true);
+  bool resultCFG = demoFunc.BuildGeneralCFG("build Demo1 cfg");
+  ASSERT_EQ(resultCFG, true);
+  demoFunc.LabelGenStmt();
+  demoFunc.LabelGenBB();
+  GeneralBB *bb1 = static_cast<GeneralBB*>(demoFunc.genBBHead->GetNext());
+  EXPECT_EQ(bb1->GetNext(), demoFunc.genBBTail);
+  EXPECT_EQ(bb1->GetStmtHead()->GetID(), 1);
+  EXPECT_EQ(bb1->GetStmtTail()->GetID(), 2);
+  EXPECT_EQ(demoFunc.HasDeadBB(), false);
+}
+
+/* GenStmtDemo2:BB_StmtAux
+ * 0   StmtHead
+ * 1   StmtAuxPre
+ * 2   Stmt (fallthru = true)
+ * 3   Stmt (fallthru = false)
+ * 4   StmtAuxPost
+ * 5   StmtTail
+ */
+void FEFunctionDemo::LoadGenStmtDemo2() {
+  Init();
+  mapIdxStmt.clear();
+  (void)NewGenStmt<GeneralStmtAuxPre>(1);
+  (void)NewGenStmt<GeneralStmt>(2);
+  GeneralStmt *stmt3 = NewGenStmt<GeneralStmt>(3);
+  (void)NewGenStmt<GeneralStmtAuxPost>(4);
+  stmt3->SetFallThru(false);
+}
+
+TEST_F(FEFunctionTest, GeneralBBBuildForBB_StmtAux) {
+  demoFunc.LoadGenStmtDemo2();
+  bool resultBB = demoFunc.BuildGeneralBB("build Demo2 bb");
+  ASSERT_EQ(resultBB, true);
+  bool resultCFG = demoFunc.BuildGeneralCFG("build Demo2 cfg");
+  ASSERT_EQ(resultCFG, true);
+  demoFunc.LabelGenStmt();
+  demoFunc.LabelGenBB();
+  GeneralBB *bb1 = static_cast<GeneralBB*>(demoFunc.genBBHead->GetNext());
+  EXPECT_EQ(bb1->GetNext(), demoFunc.genBBTail);
+  EXPECT_EQ(bb1->GetStmtHead()->GetID(), 1);
+  EXPECT_EQ(bb1->GetStmtTail()->GetID(), 4);
+  EXPECT_EQ(bb1->GetStmtNoAuxHead()->GetID(), 2);
+  EXPECT_EQ(bb1->GetStmtNoAuxTail()->GetID(), 3);
+  EXPECT_EQ(demoFunc.HasDeadBB(), false);
+}
+
+/* GenStmtDemo3:CFG
+ *     --- BB0 ---
+ * 0   StmtHead
+ *     --- BB1 ---
+ * 1   StmtAuxPre
+ * 2   StmtMultiOut (fallthru = true, out = {8})
+ * 3   StmtAuxPost
+ *     --- BB2 ---
+ * 4   StmtAuxPre
+ * 5   Stmt (fallthru = false)
+ * 6   StmtAuxPost
+ *     --- BB3 ---
+ * 7   StmtAuxPre
+ * 8   StmtMultiIn (fallthru = true, in = {2})
+ * 9   Stmt (fallthru = false)
+ * 10  StmtAuxPos
+ *     --- BB4 ---
+ * 11  StmtTail
+ *
+ * GenStmtDemo3_CFG:
+ *      BB0
+ *       |
+ *      BB1
+ *      / \
+ *   BB2   BB3
+ */
+void FEFunctionDemo::LoadGenStmtDemo3() {
+  Init();
+  mapIdxStmt.clear();
+  // --- BB1 ---
+  (void)NewGenStmt<GeneralStmtAuxPre>(1);
+  GeneralStmt *stmt2 = NewGenStmt<GeneralStmt>(GeneralStmtKind::kStmtMultiOut, 2);
+  (void)NewGenStmt<GeneralStmtAuxPost>(3);
+  // --- BB2 ---
+  (void)NewGenStmt<GeneralStmtAuxPre>(4);
+  GeneralStmt *stmt5 = NewGenStmt<GeneralStmt>(5);
+  stmt5->SetFallThru(false);
+  (void)NewGenStmt<GeneralStmtAuxPost>(6);
+  // --- BB3 ---
+  (void)NewGenStmt<GeneralStmtAuxPre>(7);
+  GeneralStmt *stmt8 = NewGenStmt<GeneralStmt>(GeneralStmtKind::kStmtMultiIn, 8);
+  GeneralStmt *stmt9 = NewGenStmt<GeneralStmt>(9);
+  stmt9->SetFallThru(false);
+  (void)NewGenStmt<GeneralStmtAuxPost>(10);
+  // Link
+  stmt2->AddSucc(stmt8);
+  stmt8->AddPred(stmt2);
+}
+
+TEST_F(FEFunctionTest, GeneralBBBuildForCFG) {
+  demoFunc.LoadGenStmtDemo3();
+  bool resultBB = demoFunc.BuildGeneralBB("build Demo3 bb");
+  ASSERT_EQ(resultBB, true);
+  bool resultCFG = demoFunc.BuildGeneralCFG("build Demo3 cfg");
+  ASSERT_EQ(resultCFG, true);
+  demoFunc.LabelGenStmt();
+  demoFunc.LabelGenBB();
+  // Check BB
+  GeneralBB *bb1 = static_cast<GeneralBB*>(demoFunc.genBBHead->GetNext());
+  ASSERT_NE(bb1, demoFunc.genBBTail);
+  GeneralBB *bb2 = static_cast<GeneralBB*>(bb1->GetNext());
+  ASSERT_NE(bb2, demoFunc.genBBTail);
+  GeneralBB *bb3 = static_cast<GeneralBB*>(bb2->GetNext());
+  ASSERT_NE(bb3, demoFunc.genBBTail);
+  // Check BB's detail
+  EXPECT_EQ(bb1->GetStmtHead()->GetID(), 1);
+  EXPECT_EQ(bb1->GetStmtNoAuxHead()->GetID(), 2);
+  EXPECT_EQ(bb1->GetStmtNoAuxTail()->GetID(), 2);
+  EXPECT_EQ(bb1->GetStmtTail()->GetID(), 3);
+  EXPECT_EQ(bb2->GetStmtHead()->GetID(), 4);
+  EXPECT_EQ(bb2->GetStmtNoAuxHead()->GetID(), 5);
+  EXPECT_EQ(bb2->GetStmtNoAuxTail()->GetID(), 5);
+  EXPECT_EQ(bb2->GetStmtTail()->GetID(), 6);
+  EXPECT_EQ(bb3->GetStmtHead()->GetID(), 7);
+  EXPECT_EQ(bb3->GetStmtNoAuxHead()->GetID(), 8);
+  EXPECT_EQ(bb3->GetStmtNoAuxTail()->GetID(), 9);
+  EXPECT_EQ(bb3->GetStmtTail()->GetID(), 10);
+  // Check CFG
+  EXPECT_EQ(bb1->GetPredBBs().size(), 1);
+  EXPECT_EQ(bb1->IsPredBB(0U), true);
+  EXPECT_EQ(bb1->GetSuccBBs().size(), 2);
+  EXPECT_EQ(bb1->IsSuccBB(2), true);
+  EXPECT_EQ(bb1->IsSuccBB(3), true);
+  EXPECT_EQ(bb2->GetPredBBs().size(), 1);
+  EXPECT_EQ(bb2->IsPredBB(1), true);
+  EXPECT_EQ(bb2->GetSuccBBs().size(), 0);
+  EXPECT_EQ(bb3->GetPredBBs().size(), 1);
+  EXPECT_EQ(bb3->IsPredBB(1), true);
+  EXPECT_EQ(bb3->GetSuccBBs().size(), 0);
+  EXPECT_EQ(demoFunc.HasDeadBB(), false);
+}
+
+/* GenStmtDemo4:CFG_Fail
+ * 0   StmtHead
+ * 1   Stmt (fallthru = true)
+ * 2   Stmt (fallthru = true)
+ * 3   StmtTail
+ */
+void FEFunctionDemo::LoadGenStmtDemo4() {
+  Init();
+  mapIdxStmt.clear();
+  (void)NewGenStmt<GeneralStmt>(1);
+  (void)NewGenStmt<GeneralStmt>(2);
+}
+
+TEST_F(FEFunctionTest, GeneralBBBuildForCFG_Fail) {
+  demoFunc.LoadGenStmtDemo4();
+  bool resultBB = demoFunc.BuildGeneralBB("build Demo4 bb");
+  ASSERT_EQ(resultBB, true);
+  bool resultCFG = demoFunc.BuildGeneralCFG("build Demo4 cfg");
+  ASSERT_EQ(resultCFG, false);
+}
+
+/* GenStmtDemo5:CFG_DeadBB
+ *     --- BB0 ---
+ * 0   StmtHead
+ *     --- BB1 ---
+ * 1   Stmt (fallthru = true)
+ * 2   Stmt (fallthru = false)
+ *     --- BB2 ---
+ * 3   Stmt (fallthru = false)
+ *     --- BB3 ---
+ * 4   StmtTail
+ *
+ * GenStmtDemo5_CFG:
+ *      BB0
+ *       |
+ *      BB1  BB2(DeadBB)
+ */
+void FEFunctionDemo::LoadGenStmtDemo5() {
+  Init();
+  mapIdxStmt.clear();
+  (void)NewGenStmt<GeneralStmt>(1);
+  GeneralStmt *stmt2 = NewGenStmt<GeneralStmt>(2);
+  stmt2->SetFallThru(false);
+  GeneralStmt *stmt3 = NewGenStmt<GeneralStmt>(3);
+  stmt3->SetFallThru(false);
+}
+
+TEST_F(FEFunctionTest, GeneralBBBuildForCFG_DeadBB) {
+  demoFunc.LoadGenStmtDemo5();
+  bool resultBB = demoFunc.BuildGeneralBB("build Demo5 bb");
+  ASSERT_EQ(resultBB, true);
+  bool resultCFG = demoFunc.BuildGeneralCFG("build Demo5 cfg");
+  ASSERT_EQ(resultCFG, true);
+  demoFunc.LabelGenStmt();
+  demoFunc.LabelGenBB();
+  // Check BB
+  GeneralBB *bb1 = static_cast<GeneralBB*>(demoFunc.genBBHead->GetNext());
+  ASSERT_NE(bb1, demoFunc.genBBTail);
+  GeneralBB *bb2 = static_cast<GeneralBB*>(bb1->GetNext());
+  ASSERT_NE(bb2, demoFunc.genBBTail);
+  // Check BB's detail
+  EXPECT_EQ(bb1->GetStmtHead()->GetID(), 1);
+  EXPECT_EQ(bb1->GetStmtTail()->GetID(), 2);
+  EXPECT_EQ(bb2->GetStmtHead()->GetID(), 3);
+  EXPECT_EQ(bb2->GetStmtTail()->GetID(), 3);
+  // Check CFG
+  EXPECT_EQ(bb1->GetPredBBs().size(), 1);
+  EXPECT_EQ(bb1->IsPredBB(0U), true);
+  EXPECT_EQ(bb2->GetSuccBBs().size(), 0);
+  EXPECT_EQ(demoFunc.HasDeadBB(), true);
+}
+}  // namespace maple
\ No newline at end of file
diff --git a/src/mplfe/test/fe_struct_elem_info_test.cpp b/src/mplfe/test/fe_struct_elem_info_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..85871643c7a806a3774412113fe973166efcb372
--- /dev/null
+++ b/src/mplfe/test/fe_struct_elem_info_test.cpp
@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v1 for more details.
+ */
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+#include "global_tables.h"
+#include "namemangler.h"
+#include "fe_struct_elem_info.h"
+#include "fe_manager.h"
+#include "mplfe_ut_environment.h"
+#include "redirect_buffer.h"
+
+namespace maple {
+class FEStructFieldInfoTest : public testing::Test, public RedirectBuffer {
+ public:
+  FEStructFieldInfoTest()
+      : mirBuilder(&MPLFEUTEnvironment::GetMIRModule()) {}
+
+  virtual ~FEStructFieldInfoTest() = default;
+
+  MIRBuilder mirBuilder;
+};
+
+TEST_F(FEStructFieldInfoTest, FEStructFieldInfo) {
+  std::string fullNameJava = "Ljava/lang/Integer;|MIN_VALUE|I";
+  std::string fullNameMpl = namemangler::EncodeName(fullNameJava);
+  GStrIdx fullNameIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(fullNameMpl);
+  FEStructFieldInfo info(fullNameIdx, kSrcLangJava, true);
+  std::string structName = GlobalTables::GetStrTable().GetStringFromStrIdx(info.structNameIdx);
+  std::string elemName = GlobalTables::GetStrTable().GetStringFromStrIdx(info.elemNameIdx);
+  std::string signatureName = GlobalTables::GetStrTable().GetStringFromStrIdx(info.signatureNameIdx);
+  EXPECT_EQ(structName, namemangler::EncodeName("Ljava/lang/Integer;"));
+  EXPECT_EQ(elemName, namemangler::EncodeName("MIN_VALUE"));
+  EXPECT_EQ(signatureName, namemangler::EncodeName("I"));
+  EXPECT_EQ(info.fieldType->IsScalar(), true);
+}
+
+TEST_F(FEStructFieldInfoTest, SearchStructFieldJava) {
+  std::string fullNameJava = "Ljava/lang/Integer;|MIN_VALUE|I";
+  std::string fullNameMpl = namemangler::EncodeName(fullNameJava);
+  GStrIdx fullNameIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(fullNameMpl);
+  FEStructFieldInfo info(fullNameIdx, kSrcLangJava, true);
+  MIRStructType *structType =
+      FEManager::GetTypeManager().GetStructTypeFromName(namemangler::EncodeName("Ljava/lang/Integer;"));
+  ASSERT_NE(structType, nullptr);
+  EXPECT_EQ(info.SearchStructFieldJava(*structType, mirBuilder, true), true);
+  EXPECT_EQ(info.SearchStructFieldJava(*structType, mirBuilder, false), false);
+}
+}  // namespace maple
diff --git a/src/mplfe/test/fe_type_hierarchy_test.cpp b/src/mplfe/test/fe_type_hierarchy_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..4c4a2989b60bf4157d94ed940969b373ba91843a
--- /dev/null
+++ b/src/mplfe/test/fe_type_hierarchy_test.cpp
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v1 for more details.
+ */
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+#include "fe_type_hierarchy.h"
+#include "global_tables.h"
+
+namespace maple {
+TEST(FETypeHierarchy, IsParentOf) {
+  GStrIdx idxObject = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName("Ljava_2Flang_2FObject_3B");
+  GStrIdx idxString = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName("Ljava_2Flang_2FString_3B");
+  GStrIdx idxInteger = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName("Ljava_2Flang_2FInteger_3B");
+  EXPECT_EQ(FETypeHierarchy::GetInstance().IsParentOf(idxObject, idxString), true);
+  EXPECT_EQ(FETypeHierarchy::GetInstance().IsParentOf(idxObject, idxInteger), true);
+  EXPECT_EQ(FETypeHierarchy::GetInstance().IsParentOf(idxString, idxInteger), false);
+  EXPECT_EQ(FETypeHierarchy::GetInstance().IsParentOf(idxInteger, idxString), false);
+  EXPECT_EQ(FETypeHierarchy::GetInstance().IsParentOf(idxString, idxString), true);
+}
+}  // namespace maple
\ No newline at end of file
diff --git a/src/mplfe/test/fe_type_manager_test.cpp b/src/mplfe/test/fe_type_manager_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..b79bd7ea3fbbb2ce5dba18c33975260c9164e9b6
--- /dev/null
+++ b/src/mplfe/test/fe_type_manager_test.cpp
@@ -0,0 +1,130 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v1 for more details.
+ */
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+#include "fe_manager.h"
+#include "fe_type_manager.h"
+#include "redirect_buffer.h"
+
+namespace maple {
+class FETypeManagerTest : public testing::Test, public RedirectBuffer {
+ public:
+  FETypeManagerTest() = default;
+  ~FETypeManagerTest() = default;
+};
+
+TEST_F(FETypeManagerTest, GetClassOrInterfaceType) {
+  MIRStructType *structType = FEManager::GetTypeManager().GetClassOrInterfaceType("Ljava_2Flang_2FObject_3B");
+  EXPECT_NE(structType, nullptr);
+  if (structType != nullptr) {
+    std::string mplName = structType->GetCompactMplTypeName();
+    EXPECT_EQ(mplName, "Ljava_2Flang_2FObject_3B");
+  }
+  MIRStructType *structTypeUnknown = FEManager::GetTypeManager().GetClassOrInterfaceType("LUnknown");
+  EXPECT_EQ(structTypeUnknown, nullptr);
+}
+
+TEST_F(FETypeManagerTest, GetClassOrInterfaceTypeFlag) {
+  FETypeFlag flag = FEManager::GetTypeManager().GetClassOrInterfaceTypeFlag("Ljava_2Flang_2FObject_3B");
+  EXPECT_EQ(flag, FETypeFlag::kSrcMpltSys);
+  FETypeFlag flagUnknown = FEManager::GetTypeManager().GetClassOrInterfaceTypeFlag("LUnknown");
+  EXPECT_EQ(flagUnknown, FETypeFlag::kDefault);
+}
+
+TEST_F(FETypeManagerTest, CreateClassOrInterfaceType) {
+  MIRStructType *structType1 = FEManager::GetTypeManager().CreateClassOrInterfaceType("LNewClass", false,
+                                                                                      FETypeFlag::kSrcInput);
+  EXPECT_NE(structType1, nullptr);
+  if (structType1 != nullptr) {
+    std::string mplName = structType1->GetCompactMplTypeName();
+    EXPECT_EQ(mplName, "LNewClass");
+    EXPECT_EQ(structType1->GetKind(), kTypeClassIncomplete);
+  }
+  MIRStructType *structType2 = FEManager::GetTypeManager().CreateClassOrInterfaceType("LNewInterface", true,
+                                                                                      FETypeFlag::kSrcInput);
+  EXPECT_NE(structType2, nullptr);
+  if (structType2 != nullptr) {
+    std::string mplName = structType2->GetCompactMplTypeName();
+    EXPECT_EQ(mplName, "LNewInterface");
+    EXPECT_EQ(structType2->GetKind(), kTypeInterfaceIncomplete);
+  }
+}
+
+TEST_F(FETypeManagerTest, GetOrCreateClassOrInterfaceType) {
+  bool isCreate = false;
+  MIRStructType *structType1 = FEManager::GetTypeManager().GetOrCreateClassOrInterfaceType("Ljava_2Flang_2FObject_3B",
+                                                                                           false,
+                                                                                           FETypeFlag::kSrcUnknown,
+                                                                                           isCreate);
+  EXPECT_EQ(isCreate, false);
+  ASSERT_NE(structType1, nullptr);
+  std::string mplName1 = structType1->GetCompactMplTypeName();
+  EXPECT_EQ(mplName1, "Ljava_2Flang_2FObject_3B");
+  EXPECT_EQ(structType1->GetKind(), kTypeClass);
+  MIRStructType *structType2 = FEManager::GetTypeManager().GetOrCreateClassOrInterfaceType("LNewClass2",
+                                                                                           false,
+                                                                                           FETypeFlag::kSrcUnknown,
+                                                                                           isCreate);
+  EXPECT_EQ(isCreate, true);
+  ASSERT_NE(structType2, nullptr);
+  std::string mplName2 = structType2->GetCompactMplTypeName();
+  EXPECT_EQ(mplName2, "LNewClass2");
+  EXPECT_EQ(structType2->GetKind(), kTypeClassIncomplete);
+}
+
+TEST_F(FETypeManagerTest, GetOrCreateClassOrInterfacePtrType) {
+  bool isCreate = false;
+  MIRType *ptrType = FEManager::GetTypeManager().GetOrCreateClassOrInterfacePtrType("Ljava_2Flang_2FObject_3B",
+                                                                                    false, FETypeFlag::kSrcUnknown,
+                                                                                    isCreate);
+  ASSERT_NE(ptrType, nullptr);
+  RedirectCout();
+  ptrType->Dump(0);
+  EXPECT_EQ(GetBufferString(), "<* <$Ljava_2Flang_2FObject_3B>>");
+  RestoreCout();
+}
+
+TEST_F(FETypeManagerTest, GetOrCreateTypeFromName) {
+  // Prim Type
+  MIRType *typePrim = FEManager::GetTypeManager().GetOrCreateTypeFromName("I",
+                                                                          FETypeFlag::kSrcUnknown, false);
+  ASSERT_NE(typePrim, nullptr);
+  EXPECT_EQ(typePrim, GlobalTables::GetTypeTable().GetInt32());
+  // Object Type
+  MIRType *typeObject = FEManager::GetTypeManager().GetOrCreateTypeFromName("Ljava_2Flang_2FObject_3B",
+                                                                            FETypeFlag::kSrcUnknown, true);
+  ASSERT_NE(typeObject, nullptr);
+  RedirectCout();
+  typeObject->Dump(0);
+  EXPECT_EQ(GetBufferString(), "<* <$Ljava_2Flang_2FObject_3B>>");
+  RestoreCout();
+  // Array Type
+  MIRType *typeArray = FEManager::GetTypeManager().GetOrCreateTypeFromName("ALjava_2Flang_2FObject_3B",
+                                                                           FETypeFlag::kSrcUnknown, true);
+  ASSERT_NE(typeArray, nullptr);
+  RedirectCout();
+  typeArray->Dump(0);
+  EXPECT_EQ(GetBufferString(), "<* <[] <* <$Ljava_2Flang_2FObject_3B>>>>");
+  RestoreCout();
+  // Array Type2
+  MIRType *typeArray2 = FEManager::GetTypeManager().GetOrCreateTypeFromName("AALjava_2Flang_2FObject_3B",
+                                                                            FETypeFlag::kSrcUnknown, true);
+  ASSERT_NE(typeArray2, nullptr);
+  RedirectCout();
+  typeArray2->Dump(0);
+  EXPECT_EQ(GetBufferString(), "<* <[] <* <[] <* <$Ljava_2Flang_2FObject_3B>>>>>>");
+  RestoreCout();
+}
+}  // namespace maple
\ No newline at end of file
diff --git a/src/mplfe/test/fe_utils_test.cpp b/src/mplfe/test/fe_utils_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..0ed6575c5ebe0b443731c02e5a058950b4565d4e
--- /dev/null
+++ b/src/mplfe/test/fe_utils_test.cpp
@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v1 for more details.
+ */
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+#include "fe_utils.h"
+
+namespace maple {
+TEST(FEUtils, Split) {
+  std::string str = "A,B,C";
+  std::vector<std::string> results = FEUtils::Split(str, ',');
+  ASSERT_EQ(results.size(), 3);
+  EXPECT_EQ(results[0], "A");
+  EXPECT_EQ(results[1], "B");
+  EXPECT_EQ(results[2], "C");
+}
+}  // namespace maple
\ No newline at end of file
diff --git a/src/mplfe/test/feir_builder_test.cpp b/src/mplfe/test/feir_builder_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..6f86efb1fb1f91874e0e33e51cbe6043ebabcec0
--- /dev/null
+++ b/src/mplfe/test/feir_builder_test.cpp
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v1 for more details.
+ */
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+#include <memory>
+#include <unordered_set>
+#include <unordered_map>
+#include "feir_test_base.h"
+#include "feir_stmt.h"
+#include "feir_var.h"
+#include "feir_var_reg.h"
+#include "feir_var_name.h"
+#include "feir_type_helper.h"
+#include "feir_builder.h"
+#include "mplfe_ut_regx.h"
+
+namespace maple {
+class FEIRBuilderTest : public FEIRTestBase {
+ public:
+  FEIRBuilderTest() = default;
+  virtual ~FEIRBuilderTest() = default;
+};
+
+// ---------- FEIRStmtDAssign ----------
+TEST_F(FEIRBuilderTest, CreateExprDRead) {
+  UniqueFEIRExpr expr = FEIRBuilder::CreateExprDRead(FEIRBuilder::CreateVarReg(0, PTY_i32));
+  BaseNode *mirNode = expr->GenMIRNode(mirBuilder);
+  RedirectCout();
+  mirNode->Dump();
+  std::string dumpStr = GetBufferString();
+  std::string pattern = std::string("dread i32 %Reg0_i32") + MPLFEUTRegx::Any();
+  EXPECT_EQ(MPLFEUTRegx::Match(dumpStr, pattern), true);
+  RestoreCout();
+}
+}  // namespace maple
diff --git a/src/mplfe/test/feir_stmt_dfg_test.cpp b/src/mplfe/test/feir_stmt_dfg_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..307b6ec6e0a022cac3fd1abcfe9612059fc1ed2b
--- /dev/null
+++ b/src/mplfe/test/feir_stmt_dfg_test.cpp
@@ -0,0 +1,264 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v1 for more details.
+ */
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+#include <memory>
+#include <vector>
+#include <list>
+#include "feir_test_base.h"
+#include "feir_stmt.h"
+#include "feir_var.h"
+#include "feir_var_reg.h"
+#include "feir_var_name.h"
+#include "feir_type_helper.h"
+#include "feir_builder.h"
+
+namespace maple {
+class FEIRDFGTest : public FEIRTestBase {
+ public:
+  std::vector<UniqueFEIRVar> vars;
+  std::vector<UniqueFEIRStmt> checkPoints;
+  FEIRDFGTest() = default;
+  virtual ~FEIRDFGTest() = default;
+  void Init(uint32 nVar, uint32 nCheckPoint) {
+    vars.clear();
+    checkPoints.clear();
+    vars.resize(nVar);
+    for (uint i = 0; i < nCheckPoint; i++) {
+      checkPoints.push_back(std::make_unique<FEIRStmtCheckPoint>());
+    }
+  }
+
+  void AddVar2DFGNodes(std::list<UniqueFEIRVar*> &nodes, uint32 idx, UniqueFEIRVar var, bool isDef) {
+    CHECK_FATAL(idx < vars.size(), "index out of range");
+    var->SetDef(isDef);
+    vars[idx].reset(var.release());
+    nodes.push_back(&vars[idx]);
+  }
+
+  void BuildDFG(const std::string &str) {
+    if (str.length() == 0) {
+      return;
+    }
+    std::string item;
+    std::string remainStr = str;
+    do {
+      size_t npos = remainStr.find(',');
+      item = remainStr.substr(0, npos);
+      if (item.length() > 0) {
+        size_t npos2 = item.find("->");
+        std::string strSrc = item.substr(0, npos2);
+        std::string strDst = item.substr(npos2 + 2);
+        uint32 src = std::atoi(strSrc.c_str());
+        uint32 dst = std::atoi(strDst.c_str());
+        TransformCheckPoint(checkPoints[dst])->AddPredCheckPoint(checkPoints[src]);
+      }
+      if (npos != std::string::npos) {
+        remainStr = remainStr.substr(npos + 1);
+      } else {
+        remainStr = "";
+      }
+    } while (remainStr.length() > 0);
+  }
+
+  FEIRStmtCheckPoint *TransformCheckPoint(const UniqueFEIRStmt &stmtCheckPoint) {
+    if (stmtCheckPoint == nullptr || stmtCheckPoint->GetKind() != FEIRNodeKind::kStmtCheckPoint) {
+      CHECK_FATAL(false, "invalid input");
+    }
+    return static_cast<FEIRStmtCheckPoint*>(stmtCheckPoint.get());
+  }
+};
+
+// ---------- FEIRDFGNode ----------
+TEST_F(FEIRDFGTest, FEIRDFGNode_VarReg_EqualsTo) {
+  std::unique_ptr<FEIRVar> varReg1 = FEIRBuilder::CreateVarReg(0, PTY_i32);
+  std::unique_ptr<FEIRVar> varReg2 = FEIRBuilder::CreateVarReg(0, PTY_i64);
+  FEIRDFGNode node1(varReg1);
+  FEIRDFGNode node2(varReg2);
+  FEIRDFGNode node11(node1);
+  FEIRDFGNode node21(node2);
+  FEIRDFGNode node12 = node11;
+  FEIRDFGNode node22 = node21;
+  EXPECT_EQ(node12 == node22, true);
+}
+
+TEST_F(FEIRDFGTest, FEIRDFGNode_VarDiff_EqualsTo) {
+  std::unique_ptr<FEIRVar> varReg1 = FEIRBuilder::CreateVarReg(0, PTY_i32);
+  std::unique_ptr<FEIRVar> varReg2 = FEIRBuilder::CreateVarName("testVar2", PTY_i32, false, false);
+  (void)GlobalTables::GetStrTable().GetOrCreateStrIdxFromName("testVar3");
+  std::unique_ptr<FEIRVar> varReg3 = FEIRBuilder::CreateVarName("testVar3", PTY_i32, false, false);
+  FEIRDFGNode node1(varReg1);
+  FEIRDFGNode node2(varReg2);
+  FEIRDFGNode node3(varReg3);
+  EXPECT_EQ(node1 == node2, false);
+  EXPECT_EQ(node1 == node3, false);
+  EXPECT_EQ(node2 == node3, false);
+}
+
+TEST_F(FEIRDFGTest, FEIRDFGNode_VarReg_set) {
+  std::unique_ptr<FEIRVar> varReg1 = FEIRBuilder::CreateVarReg(0, PTY_i32);
+  std::unique_ptr<FEIRVar> varReg2 = FEIRBuilder::CreateVarReg(0, PTY_i64);
+  std::unique_ptr<FEIRVar> varReg3 = FEIRBuilder::CreateVarReg(1, PTY_i32);
+  std::unique_ptr<FEIRVar> varReg4 = FEIRBuilder::CreateVarReg(0, PTY_u1);
+  std::unordered_set<FEIRDFGNode, FEIRDFGNodeHash> set1;
+  set1.insert(FEIRDFGNode(varReg1));
+  set1.insert(FEIRDFGNode(varReg2));
+  EXPECT_EQ(set1.size(), 1);
+  set1.insert(FEIRDFGNode(varReg3));
+  EXPECT_EQ(set1.size(), 2);
+  set1.erase(FEIRDFGNode(varReg4));
+  EXPECT_EQ(set1.size(), 1);
+}
+
+// ---------- FEIRStmtCheckPoint ----------
+/*
+ * Test1
+ *   DFG: mplfe/doc/images/ut_cases/DFG/Test1.dot
+ *   Image: mplfe/doc/images/ut_cases/DFG/Test1.png
+ */
+TEST_F(FEIRDFGTest, CheckPointTest1) {
+  Init(2, 1);
+  // BB0
+  std::list<UniqueFEIRVar*> stmt0;
+  AddVar2DFGNodes(stmt0, 0, FEIRBuilder::CreateVarReg(0, PTY_i32), true);
+  std::list<UniqueFEIRVar*> stmt1;
+  AddVar2DFGNodes(stmt1, 1, FEIRBuilder::CreateVarReg(0, PTY_i32), false);
+  TransformCheckPoint(checkPoints[0])->RegisterDFGNodes(stmt0);
+  TransformCheckPoint(checkPoints[0])->RegisterDFGNodes(stmt1);
+  // Build DFG
+  BuildDFG("");
+  std::set<UniqueFEIRVar*> &defs = TransformCheckPoint(checkPoints[0])->CalcuDef(vars[1]);
+  ASSERT_EQ(defs.size(), 1);
+  EXPECT_NE(defs.find(&vars[0]), defs.end());
+}
+
+/*
+ * Test2
+ *   DFG: mplfe/doc/images/ut_cases/DFG/Test2.dot
+ *   Image: mplfe/doc/images/ut_cases/DFG/Test2.png
+ */
+TEST_F(FEIRDFGTest, CheckPointTest2) {
+  Init(2, 2);
+  // BB0
+  std::list<UniqueFEIRVar*> stmt0;
+  AddVar2DFGNodes(stmt0, 0, FEIRBuilder::CreateVarReg(0, PTY_i32), true);
+  TransformCheckPoint(checkPoints[0])->RegisterDFGNodes(stmt0);
+  // BB1
+  std::list<UniqueFEIRVar*> stmt1;
+  AddVar2DFGNodes(stmt1, 1, FEIRBuilder::CreateVarReg(0, PTY_i32), false);
+  TransformCheckPoint(checkPoints[1])->RegisterDFGNodes(stmt1);
+  // Build DFG
+  BuildDFG("0->1");
+  std::set<UniqueFEIRVar*> &defs = TransformCheckPoint(checkPoints[1])->CalcuDef(vars[1]);
+  ASSERT_EQ(defs.size(), 1);
+  EXPECT_NE(defs.find(&vars[0]), defs.end());
+}
+
+/*
+ * Test3
+ *   DFG: mplfe/doc/images/ut_cases/DFG/Test3.dot
+ *   Image: mplfe/doc/images/ut_cases/DFG/Test3.png
+ */
+TEST_F(FEIRDFGTest, Test3) {
+  Init(4, 4);
+  // BB0
+  std::list<UniqueFEIRVar*> stmt0;
+  AddVar2DFGNodes(stmt0, 0, FEIRBuilder::CreateVarReg(0, PTY_i32), true);
+  TransformCheckPoint(checkPoints[0])->RegisterDFGNodes(stmt0);
+  // BB1
+  std::list<UniqueFEIRVar*> stmt1;
+  AddVar2DFGNodes(stmt1, 1, FEIRBuilder::CreateVarReg(0, PTY_i32), true);
+  TransformCheckPoint(checkPoints[1])->RegisterDFGNodes(stmt1);
+  // BB2
+  std::list<UniqueFEIRVar*> stmt2;
+  TransformCheckPoint(checkPoints[2])->RegisterDFGNodes(stmt2);
+  // BB3
+  std::list<UniqueFEIRVar*> stmt3;
+  AddVar2DFGNodes(stmt3, 3, FEIRBuilder::CreateVarReg(0, PTY_i32), false);
+  TransformCheckPoint(checkPoints[3])->RegisterDFGNodes(stmt3);
+  // Build DFG
+  BuildDFG("0->1,0->2,1->3,2->3");
+  std::set<UniqueFEIRVar*> &defs = TransformCheckPoint(checkPoints[3])->CalcuDef(vars[3]);
+  ASSERT_EQ(defs.size(), 2);
+  EXPECT_NE(defs.find(&vars[0]), defs.end());
+  EXPECT_NE(defs.find(&vars[1]), defs.end());
+}
+
+/*
+ * Test4
+ *   DFG: mplfe/doc/images/ut_cases/DFG/Test4.dot
+ *   Image: mplfe/doc/images/ut_cases/DFG/Test4.png
+ */
+TEST_F(FEIRDFGTest, Test4) {
+  Init(4, 4);
+  // BB0
+  std::list<UniqueFEIRVar*> stmt0;
+  AddVar2DFGNodes(stmt0, 0, FEIRBuilder::CreateVarReg(0, PTY_i32), true);
+  TransformCheckPoint(checkPoints[0])->RegisterDFGNodes(stmt0);
+  // BB1
+  std::list<UniqueFEIRVar*> stmt1;
+  AddVar2DFGNodes(stmt1, 1, FEIRBuilder::CreateVarReg(0, PTY_i32), true);
+  TransformCheckPoint(checkPoints[1])->RegisterDFGNodes(stmt1);
+  // BB2
+  std::list<UniqueFEIRVar*> stmt2;
+  AddVar2DFGNodes(stmt2, 2, FEIRBuilder::CreateVarReg(0, PTY_i32), true);
+  TransformCheckPoint(checkPoints[2])->RegisterDFGNodes(stmt2);
+  // BB3
+  std::list<UniqueFEIRVar*> stmt3;
+  AddVar2DFGNodes(stmt3, 3, FEIRBuilder::CreateVarReg(0, PTY_i32), false);
+  TransformCheckPoint(checkPoints[3])->RegisterDFGNodes(stmt3);
+  // Build DFG
+  BuildDFG("0->1,0->2,1->3,2->3");
+  std::set<UniqueFEIRVar*> &defs = TransformCheckPoint(checkPoints[3])->CalcuDef(vars[3]);
+  ASSERT_EQ(defs.size(), 2);
+  EXPECT_EQ(defs.find(&vars[0]), defs.end());
+  EXPECT_NE(defs.find(&vars[1]), defs.end());
+  EXPECT_NE(defs.find(&vars[2]), defs.end());
+}
+
+/*
+ * Test5
+ *   DFG: mplfe/doc/images/ut_cases/DFG/Test5.dot
+ *   Image: mplfe/doc/images/ut_cases/DFG/Test5.png
+ */
+TEST_F(FEIRDFGTest, Test5) {
+  Init(4, 4);
+  // BB0
+  std::list<UniqueFEIRVar*> stmt0;
+  AddVar2DFGNodes(stmt0, 0, FEIRBuilder::CreateVarReg(0, PTY_i32), true);
+  TransformCheckPoint(checkPoints[0])->RegisterDFGNodes(stmt0);
+  // BB1
+  std::list<UniqueFEIRVar*> stmt1;
+  AddVar2DFGNodes(stmt1, 1, FEIRBuilder::CreateVarReg(0, PTY_i32), false);
+  TransformCheckPoint(checkPoints[1])->RegisterDFGNodes(stmt1);
+  // BB2
+  std::list<UniqueFEIRVar*> stmt2;
+  AddVar2DFGNodes(stmt2, 2, FEIRBuilder::CreateVarReg(0, PTY_i32), true);
+  TransformCheckPoint(checkPoints[2])->RegisterDFGNodes(stmt2);
+  // BB3
+  std::list<UniqueFEIRVar*> stmt3;
+  AddVar2DFGNodes(stmt3, 3, FEIRBuilder::CreateVarReg(0, PTY_i32), false);
+  TransformCheckPoint(checkPoints[3])->RegisterDFGNodes(stmt3);
+  // Build DFG
+  BuildDFG("0->1,1->2,2->3,2->1");
+  std::set<UniqueFEIRVar*> &defs1 = TransformCheckPoint(checkPoints[1])->CalcuDef(vars[1]);
+  ASSERT_EQ(defs1.size(), 2);
+  EXPECT_NE(defs1.find(&vars[0]), defs1.end());
+  EXPECT_NE(defs1.find(&vars[2]), defs1.end());
+  std::set<UniqueFEIRVar*> &defs3 = TransformCheckPoint(checkPoints[3])->CalcuDef(vars[3]);
+  ASSERT_EQ(defs3.size(), 1);
+  EXPECT_NE(defs3.find(&vars[2]), defs3.end());
+}
+}  // namespace maple
\ No newline at end of file
diff --git a/src/mplfe/test/feir_stmt_test.cpp b/src/mplfe/test/feir_stmt_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..62b1dd75423ce4b4dd27e5a84a1c7d77b932ba07
--- /dev/null
+++ b/src/mplfe/test/feir_stmt_test.cpp
@@ -0,0 +1,313 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v1 for more details.
+ */
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+#include <memory>
+#include <unordered_set>
+#include <unordered_map>
+#include "feir_test_base.h"
+#include "feir_stmt.h"
+#include "feir_var.h"
+#include "feir_var_reg.h"
+#include "feir_var_name.h"
+#include "feir_type_helper.h"
+#include "feir_builder.h"
+#include "mplfe_ut_regx.h"
+
+namespace maple {
+class FEIRStmtTest : public FEIRTestBase {
+ public:
+  FEIRStmtTest() = default;
+  virtual ~FEIRStmtTest() = default;
+};
+
+// ---------- FEIRExprConst ----------
+TEST_F(FEIRStmtTest, FEIRExprConst_i64) {
+  std::unique_ptr<FEIRExprConst> exprConst = std::make_unique<FEIRExprConst>(int64{ 0x100 }, PTY_i64);
+  std::unique_ptr<FEIRExpr> exprConst2 = exprConst->Clone();
+  BaseNode *baseNode = exprConst2->GenMIRNode(mirBuilder);
+  RedirectCout();
+  baseNode->Dump();
+  EXPECT_EQ(GetBufferString(), "constval i64 256\n");
+  RestoreCout();
+}
+
+TEST_F(FEIRStmtTest, FEIRExprConst_u64) {
+  std::unique_ptr<FEIRExprConst> exprConst = std::make_unique<FEIRExprConst>(uint64{ 0x100 }, PTY_u64);
+  std::unique_ptr<FEIRExpr> exprConst2 = exprConst->Clone();
+  BaseNode *baseNode = exprConst2->GenMIRNode(mirBuilder);
+  RedirectCout();
+  baseNode->Dump();
+  EXPECT_EQ(GetBufferString(), "constval u64 256\n");
+  RestoreCout();
+}
+
+TEST_F(FEIRStmtTest, FEIRExprConst_f32) {
+  std::unique_ptr<FEIRExprConst> exprConst = std::make_unique<FEIRExprConst>(1.5f);
+  std::unique_ptr<FEIRExpr> exprConst2 = exprConst->Clone();
+  BaseNode *baseNode = exprConst2->GenMIRNode(mirBuilder);
+  RedirectCout();
+  baseNode->Dump();
+  EXPECT_EQ(GetBufferString(), "constval f32 1.5f\n");
+  RestoreCout();
+}
+
+TEST_F(FEIRStmtTest, FEIRExprConst_f64) {
+  std::unique_ptr<FEIRExprConst> exprConst = std::make_unique<FEIRExprConst>(1.5);
+  std::unique_ptr<FEIRExpr> exprConst2 = exprConst->Clone();
+  BaseNode *baseNode = exprConst2->GenMIRNode(mirBuilder);
+  RedirectCout();
+  baseNode->Dump();
+  EXPECT_EQ(GetBufferString(), "constval f64 1.5\n");
+  RestoreCout();
+}
+
+TEST_F(FEIRStmtTest, FEIRExprConstUnsupported) {
+  std::unique_ptr<FEIRExprConst> exprConst = std::make_unique<FEIRExprConst>(int64{ 0 }, PTY_unknown);
+  BaseNode *baseNode = exprConst->GenMIRNode(mirBuilder);
+  EXPECT_EQ(baseNode, nullptr);
+}
+
+// ---------- FEIRExprUnary ----------
+TEST_F(FEIRStmtTest, FEIRExprUnary) {
+  std::unique_ptr<FEIRVar> varReg = FEIRBuilder::CreateVarReg(0, PTY_i32);
+  std::unique_ptr<FEIRExprDRead> exprDRead = std::make_unique<FEIRExprDRead>(std::move(varReg));
+  std::unique_ptr<FEIRExprUnary> expr = std::make_unique<FEIRExprUnary>(OP_neg, std::move(exprDRead));
+  expr->GetType()->SetPrimType(PTY_i32);
+  std::unique_ptr<FEIRExpr> expr2 = expr->Clone();
+  BaseNode *baseNode = expr2->GenMIRNode(mirBuilder);
+  RedirectCout();
+  baseNode->Dump();
+  std::string dumpStr = GetBufferString();
+  std::string pattern = std::string("neg i32 \\(dread i32 %Reg0_i32\\)") + MPLFEUTRegx::Any();
+  EXPECT_EQ(MPLFEUTRegx::Match(dumpStr, pattern), true);
+  RestoreCout();
+  std::vector<FEIRVar*> varUses = expr2->GetVarUses();
+  ASSERT_EQ(varUses.size(), 1);
+}
+
+// ---------- FEIRExprTypeCvt ----------
+TEST_F(FEIRStmtTest, FEIRExprTypeCvtMode1) {
+  std::unique_ptr<FEIRVar> varReg = FEIRBuilder::CreateVarReg(0, PTY_i32);
+  std::unique_ptr<FEIRExprDRead> exprDRead = std::make_unique<FEIRExprDRead>(std::move(varReg));
+  std::unique_ptr<FEIRExprUnary> expr = std::make_unique<FEIRExprTypeCvt>(OP_cvt, std::move(exprDRead));
+  expr->GetType()->SetPrimType(PTY_f32);
+  std::unique_ptr<FEIRExpr> expr2 = expr->Clone();
+  BaseNode *baseNode = expr2->GenMIRNode(mirBuilder);
+  RedirectCout();
+  baseNode->Dump();
+  std::string dumpStr = GetBufferString();
+  std::string pattern = std::string("cvt f32 i32 \\(dread i32 %Reg0_i32\\)") + MPLFEUTRegx::Any();
+  EXPECT_EQ(MPLFEUTRegx::Match(dumpStr, pattern), true);
+  RestoreCout();
+}
+
+TEST_F(FEIRStmtTest, FEIRExprTypeCvtMode2) {
+  std::unique_ptr<FEIRVar> varReg = FEIRBuilder::CreateVarReg(0, PTY_f32);
+  std::unique_ptr<FEIRExprDRead> exprDRead = std::make_unique<FEIRExprDRead>(std::move(varReg));
+  std::unique_ptr<FEIRExprTypeCvt> expr = std::make_unique<FEIRExprTypeCvt>(OP_round, std::move(exprDRead));
+  expr->GetType()->SetPrimType(PTY_i32);
+  std::unique_ptr<FEIRExpr> expr2 = expr->Clone();
+  BaseNode *baseNode = expr2->GenMIRNode(mirBuilder);
+  RedirectCout();
+  baseNode->Dump();
+  std::string dumpStr = GetBufferString();
+  std::string pattern = std::string("round i32 f32 \\(dread f32 %Reg0_f32\\)") + MPLFEUTRegx::Any();
+  EXPECT_EQ(MPLFEUTRegx::Match(dumpStr, pattern), true);
+  RestoreCout();
+}
+
+TEST_F(FEIRStmtTest, FEIRExprTypeCvtMode3) {
+  std::unique_ptr<FEIRType> typeVar = FEIRTypeHelper::CreateTypeByJavaName("Ljava/lang/Object;", false, true);
+  std::unique_ptr<FEIRVarReg> varReg = std::make_unique<FEIRVarReg>(0, std::move(typeVar));
+  std::unique_ptr<FEIRExprDRead> exprDRead = std::make_unique<FEIRExprDRead>(std::move(varReg));
+  std::unique_ptr<FEIRType> typeDst = FEIRTypeHelper::CreateTypeByJavaName("Ljava/lang/String;", false, true);
+  std::unique_ptr<FEIRExprTypeCvt> expr = std::make_unique<FEIRExprTypeCvt>(std::move(typeDst), OP_retype,
+                                                                            std::move(exprDRead));
+  std::unique_ptr<FEIRExpr> expr2 = expr->Clone();
+  BaseNode *baseNode = expr2->GenMIRNode(mirBuilder);
+  RedirectCout();
+  baseNode->Dump();
+  std::string dumpStr = GetBufferString();
+  std::string pattern = std::string("retype ref <\\* <\\$Ljava_2Flang_2FString_3B>> \\(dread ref %Reg0_") +
+                        MPLFEUTRegx::RefIndex(MPLFEUTRegx::kAnyNumber) + "\\)" + MPLFEUTRegx::Any();
+  EXPECT_EQ(MPLFEUTRegx::Match(dumpStr, pattern), true);
+  RestoreCout();
+}
+
+// ---------- FEIRExprExtractBits ----------
+TEST_F(FEIRStmtTest, FEIRExprExtractBits) {
+  std::unique_ptr<FEIRVar> varReg = FEIRBuilder::CreateVarReg(0, PTY_i32);
+  std::unique_ptr<FEIRExprDRead> exprDRead = std::make_unique<FEIRExprDRead>(std::move(varReg));
+  std::unique_ptr<FEIRExprExtractBits> expr =
+      std::make_unique<FEIRExprExtractBits>(OP_extractbits, PTY_i32, 8, 16, std::move(exprDRead));
+  std::unique_ptr<FEIRExpr> expr2 = expr->Clone();
+  BaseNode *baseNode = expr2->GenMIRNode(mirBuilder);
+  RedirectCout();
+  baseNode->Dump();
+  std::string dumpStr = GetBufferString();
+  std::string pattern = std::string("extractbits i32 8 16 \\(dread i32 %Reg0_i32\\)") + MPLFEUTRegx::Any();
+  EXPECT_EQ(MPLFEUTRegx::Match(dumpStr, pattern), true);
+  RestoreCout();
+}
+
+TEST_F(FEIRStmtTest, FEIRExprExtractBits_sext) {
+  std::unique_ptr<FEIRVar> varReg = FEIRBuilder::CreateVarReg(0, PTY_i8);
+  std::unique_ptr<FEIRExprDRead> exprDRead = std::make_unique<FEIRExprDRead>(std::move(varReg));
+  std::unique_ptr<FEIRExprExtractBits> expr =
+      std::make_unique<FEIRExprExtractBits>(OP_sext, PTY_i32, std::move(exprDRead));
+  std::unique_ptr<FEIRExpr> expr2 = expr->Clone();
+  BaseNode *baseNode = expr2->GenMIRNode(mirBuilder);
+  RedirectCout();
+  baseNode->Dump();
+  std::string dumpStr = GetBufferString();
+  std::string pattern = std::string("sext i32 8 \\(dread i8 %Reg0_i8\\)") + MPLFEUTRegx::Any();
+  EXPECT_EQ(MPLFEUTRegx::Match(dumpStr, pattern), true);
+  RestoreCout();
+}
+
+TEST_F(FEIRStmtTest, FEIRExprExtractBits_zext) {
+  std::unique_ptr<FEIRVar> varReg = FEIRBuilder::CreateVarReg(0, PTY_u16);
+  std::unique_ptr<FEIRExprDRead> exprDRead = std::make_unique<FEIRExprDRead>(std::move(varReg));
+  std::unique_ptr<FEIRExprExtractBits> expr =
+      std::make_unique<FEIRExprExtractBits>(OP_zext, PTY_i32, std::move(exprDRead));
+  std::unique_ptr<FEIRExpr> expr2 = expr->Clone();
+  BaseNode *baseNode = expr2->GenMIRNode(mirBuilder);
+  RedirectCout();
+  baseNode->Dump();
+  std::string dumpStr = GetBufferString();
+  std::string pattern = std::string("zext i32 16 \\(dread u16 %Reg0_u16\\)") + MPLFEUTRegx::Any();
+  EXPECT_EQ(MPLFEUTRegx::Match(dumpStr, pattern), true);
+  RestoreCout();
+}
+
+// ---------- FEIRExprBinary ----------
+TEST_F(FEIRStmtTest, FEIRExprBinary_add) {
+  std::unique_ptr<FEIRVar> varReg0 = FEIRBuilder::CreateVarReg(0, PTY_i32);
+  std::unique_ptr<FEIRVar> varReg1 = FEIRBuilder::CreateVarReg(1, PTY_i32);
+  std::unique_ptr<FEIRExprDRead> exprDRead0 = std::make_unique<FEIRExprDRead>(std::move(varReg0));
+  std::unique_ptr<FEIRExprDRead> exprDRead1 = std::make_unique<FEIRExprDRead>(std::move(varReg1));
+  std::unique_ptr<FEIRExprBinary> expr =
+      std::make_unique<FEIRExprBinary>(OP_add, std::move(exprDRead0), std::move(exprDRead1));
+  std::unique_ptr<FEIRExpr> expr2 = expr->Clone();
+  BaseNode *baseNode = expr2->GenMIRNode(mirBuilder);
+  RedirectCout();
+  baseNode->Dump();
+  std::string dumpStr = GetBufferString();
+  std::string pattern = std::string("add i32 \\(dread i32 %Reg0_i32, dread i32 %Reg1_i32\\)") + MPLFEUTRegx::Any();
+  EXPECT_EQ(MPLFEUTRegx::Match(dumpStr, pattern), true);
+  RestoreCout();
+  std::vector<FEIRVar*> varUses = expr2->GetVarUses();
+  ASSERT_EQ(varUses.size(), 2);
+  EXPECT_EQ(expr2->IsNestable(), true);
+  EXPECT_EQ(expr2->IsAddrof(), false);
+}
+
+TEST_F(FEIRStmtTest, FEIRExprBinary_cmpg) {
+  std::unique_ptr<FEIRVar> varReg0 = FEIRBuilder::CreateVarReg(0, PTY_f64);
+  std::unique_ptr<FEIRVar> varReg2 = FEIRBuilder::CreateVarReg(2, PTY_f64);
+  std::unique_ptr<FEIRExprDRead> exprDRead0 = std::make_unique<FEIRExprDRead>(std::move(varReg0));
+  std::unique_ptr<FEIRExprDRead> exprDRead2 = std::make_unique<FEIRExprDRead>(std::move(varReg2));
+  std::unique_ptr<FEIRExprBinary> expr =
+      std::make_unique<FEIRExprBinary>(OP_cmpg, std::move(exprDRead0), std::move(exprDRead2));
+  std::unique_ptr<FEIRExpr> expr2 = expr->Clone();
+  BaseNode *baseNode = expr2->GenMIRNode(mirBuilder);
+  RedirectCout();
+  baseNode->Dump();
+  std::string dumpStr = GetBufferString();
+  std::string pattern = std::string("cmpg i32 f64 \\(dread f64 %Reg0_f64, dread f64 %Reg2_f64\\)") + MPLFEUTRegx::Any();
+  EXPECT_EQ(MPLFEUTRegx::Match(dumpStr, pattern), true);
+  RestoreCout();
+}
+
+TEST_F(FEIRStmtTest, FEIRExprBinary_lshr) {
+  std::unique_ptr<FEIRVar> varReg0 = FEIRBuilder::CreateVarReg(0, PTY_i32);
+  std::unique_ptr<FEIRVar> varReg1 = FEIRBuilder::CreateVarReg(1, PTY_i8);
+  std::unique_ptr<FEIRExprDRead> exprDRead0 = std::make_unique<FEIRExprDRead>(std::move(varReg0));
+  std::unique_ptr<FEIRExprDRead> exprDRead1 = std::make_unique<FEIRExprDRead>(std::move(varReg1));
+  std::unique_ptr<FEIRExprBinary> expr =
+      std::make_unique<FEIRExprBinary>(OP_lshr, std::move(exprDRead0), std::move(exprDRead1));
+  std::unique_ptr<FEIRExpr> expr2 = expr->Clone();
+  BaseNode *baseNode = expr2->GenMIRNode(mirBuilder);
+  RedirectCout();
+  baseNode->Dump();
+  std::string dumpStr = GetBufferString();
+  std::string pattern = std::string("lshr i32 \\(dread i32 %Reg0_i32, dread i8 %Reg1_i8\\)") + MPLFEUTRegx::Any();
+  EXPECT_EQ(MPLFEUTRegx::Match(dumpStr, pattern), true);
+  RestoreCout();
+}
+
+TEST_F(FEIRStmtTest, FEIRExprBinary_band) {
+  std::unique_ptr<FEIRVar> varReg0 = FEIRBuilder::CreateVarReg(0, PTY_i32);
+  std::unique_ptr<FEIRVar> varReg1 = FEIRBuilder::CreateVarReg(1, PTY_i32);
+  std::unique_ptr<FEIRExprDRead> exprDRead0 = std::make_unique<FEIRExprDRead>(std::move(varReg0));
+  std::unique_ptr<FEIRExprDRead> exprDRead1 = std::make_unique<FEIRExprDRead>(std::move(varReg1));
+  std::unique_ptr<FEIRExprBinary> expr =
+      std::make_unique<FEIRExprBinary>(OP_band, std::move(exprDRead0), std::move(exprDRead1));
+  std::unique_ptr<FEIRExpr> expr2 = expr->Clone();
+  BaseNode *baseNode = expr2->GenMIRNode(mirBuilder);
+  RedirectCout();
+  baseNode->Dump();
+  std::string dumpStr = GetBufferString();
+  std::string pattern = std::string("band i32 \\(dread i32 %Reg0_i32, dread i32 %Reg1_i32\\)") + MPLFEUTRegx::Any();
+  EXPECT_EQ(MPLFEUTRegx::Match(dumpStr, pattern), true);
+  RestoreCout();
+}
+
+// ---------- FEIRExprTernary ----------
+TEST_F(FEIRStmtTest, FEIRExprTernary_add) {
+  std::unique_ptr<FEIRVar> varReg0 = FEIRBuilder::CreateVarReg(0, PTY_u1);
+  std::unique_ptr<FEIRVar> varReg1 = FEIRBuilder::CreateVarReg(1, PTY_i32);
+  std::unique_ptr<FEIRVar> varReg2 = FEIRBuilder::CreateVarReg(2, PTY_i32);
+  std::unique_ptr<FEIRExprDRead> exprDRead0 = std::make_unique<FEIRExprDRead>(std::move(varReg0));
+  std::unique_ptr<FEIRExprDRead> exprDRead1 = std::make_unique<FEIRExprDRead>(std::move(varReg1));
+  std::unique_ptr<FEIRExprDRead> exprDRead2 = std::make_unique<FEIRExprDRead>(std::move(varReg2));
+  std::unique_ptr<FEIRExprTernary> expr =
+      std::make_unique<FEIRExprTernary>(OP_select, std::move(exprDRead0), std::move(exprDRead1), std::move(exprDRead2));
+  std::unique_ptr<FEIRExpr> expr2 = expr->Clone();
+  BaseNode *baseNode = expr2->GenMIRNode(mirBuilder);
+  RedirectCout();
+  baseNode->Dump();
+  std::string dumpStr = GetBufferString();
+  std::string pattern =
+      std::string("select i32 \\(dread u1 %Reg0_u1, dread i32 %Reg1_i32, dread i32 %Reg2_i32\\)") + MPLFEUTRegx::Any();
+  EXPECT_EQ(MPLFEUTRegx::Match(dumpStr, pattern), true);
+  RestoreCout();
+  std::vector<FEIRVar*> varUses = expr2->GetVarUses();
+  ASSERT_EQ(varUses.size(), 3);
+  EXPECT_EQ(expr2->IsNestable(), true);
+  EXPECT_EQ(expr2->IsAddrof(), false);
+}
+
+// ---------- FEIRStmtDAssign ----------
+TEST_F(FEIRStmtTest, FEIRStmtDAssign) {
+  std::unique_ptr<FEIRType> type = FEIRTypeHelper::CreateTypeByJavaName("Ljava/lang/String;", false, true);
+  std::unique_ptr<FEIRVarReg> dstVar = std::make_unique<FEIRVarReg>(0, type->Clone());
+  std::unique_ptr<FEIRVarReg> srcVar = std::make_unique<FEIRVarReg>(1, type->Clone());
+  std::unique_ptr<FEIRExprDRead> exprDRead = std::make_unique<FEIRExprDRead>(std::move(srcVar));
+  std::unique_ptr<FEIRStmtDAssign> stmtDAssign =
+      std::make_unique<FEIRStmtDAssign>(std::move(dstVar), std::move(exprDRead));
+  std::list<StmtNode*> mirNodes = stmtDAssign->GenMIRStmts(mirBuilder);
+  ASSERT_EQ(mirNodes.size(), 1);
+  RedirectCout();
+  mirNodes.front()->Dump();
+  std::string dumpStr = GetBufferString();
+  std::string pattern = std::string("dassign %Reg0_") + MPLFEUTRegx::RefIndex(MPLFEUTRegx::kAnyNumber) +
+                        " 0 \\(dread ref %Reg1_" + MPLFEUTRegx::RefIndex(MPLFEUTRegx::kAnyNumber) + "\\)" +
+                        MPLFEUTRegx::Any();
+  EXPECT_EQ(MPLFEUTRegx::Match(dumpStr, pattern), true);
+  RestoreCout();
+}
+}  // namespace maple
\ No newline at end of file
diff --git a/src/mplfe/test/feir_test_base.cpp b/src/mplfe/test/feir_test_base.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..daf93524c1a06569addcb1d01a0f7d96ed916f62
--- /dev/null
+++ b/src/mplfe/test/feir_test_base.cpp
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v1 for more details.
+ */
+#include "feir_test_base.h"
+#include "mplfe_ut_environment.h"
+
+namespace maple {
+MemPool *FEIRTestBase::mp = nullptr;
+
+FEIRTestBase::FEIRTestBase()
+    : allocator(mp),
+      mirBuilder(&MPLFEUTEnvironment::GetMIRModule()),
+      func(&MPLFEUTEnvironment::GetMIRModule(), StIdx(0, 0)) {
+  func.Init();
+  mirBuilder.SetCurrentFunction(func);
+}
+
+void FEIRTestBase::SetUpTestCase() {
+  mp = memPoolCtrler.NewMemPool("MemPool for FEIRTestBase");
+}
+
+void FEIRTestBase::TearDownTestCase() {
+  memPoolCtrler.DeleteMemPool(mp);
+  mp = nullptr;
+}
+}  // namespace maple
\ No newline at end of file
diff --git a/src/mplfe/test/feir_test_base.h b/src/mplfe/test/feir_test_base.h
new file mode 100644
index 0000000000000000000000000000000000000000..c70e02b0a6ba918dab74a51f2a85a513c1c33454
--- /dev/null
+++ b/src/mplfe/test/feir_test_base.h
@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v1 for more details.
+ */
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+#include "redirect_buffer.h"
+#include "global_tables.h"
+#include "mir_module.h"
+#include "mir_builder.h"
+
+namespace maple {
+class FEIRTestBase : public testing::Test, public RedirectBuffer {
+ public:
+  static MemPool *mp;
+  MapleAllocator allocator;
+  MIRBuilder mirBuilder;
+  MIRFunction func;
+  FEIRTestBase();
+  virtual ~FEIRTestBase() = default;
+
+  static void SetUpTestCase();
+  static void TearDownTestCase();
+};
+}  // namespace maple
\ No newline at end of file
diff --git a/src/mplfe/test/feir_type_helper_test.cpp b/src/mplfe/test/feir_type_helper_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..737052040dc36f215e90d6680fd0ec30539a6882
--- /dev/null
+++ b/src/mplfe/test/feir_type_helper_test.cpp
@@ -0,0 +1,184 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v1 for more details.
+ */
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+#include <memory>
+#include "redirect_buffer.h"
+#include "global_tables.h"
+#include "mir_module.h"
+#include "feir_type_helper.h"
+
+namespace maple {
+class FEIRTypeHelperTest : public testing::Test, public RedirectBuffer {
+ public:
+  FEIRTypeHelperTest() = default;
+  ~FEIRTypeHelperTest() = default;
+};
+
+TEST_F(FEIRTypeHelperTest, CreateTypeByPrimType_i32) {
+  std::unique_ptr<FEIRType> type1 = FEIRTypeHelper::CreateTypeByPrimType(PTY_i32, 0, false);
+  std::unique_ptr<FEIRType> type2 = FEIRTypeHelper::CreateTypeByPrimType(PTY_i32, 0, true);
+  RedirectCout();
+  type1->GenerateMIRType()->Dump(0);
+  EXPECT_EQ(GetBufferString(), "i32");
+  ClearBufferString();
+  type2->GenerateMIRType()->Dump(0);
+  EXPECT_EQ(GetBufferString(), "<* i32>");
+  RestoreCout();
+}
+
+TEST_F(FEIRTypeHelperTest, CreateTypeByJavaName_J) {
+  std::unique_ptr<FEIRType> type1 = FEIRTypeHelper::CreateTypeByJavaName("J", false, false);
+  std::unique_ptr<FEIRType> type2 = FEIRTypeHelper::CreateTypeByJavaName("J", false, true);
+  RedirectCout();
+  type1->GenerateMIRType()->Dump(0);
+  EXPECT_EQ(GetBufferString(), "i64");
+  ClearBufferString();
+  type2->GenerateMIRType()->Dump(0);
+  EXPECT_EQ(GetBufferString(), "<* i64>");
+  RestoreCout();
+}
+
+TEST_F(FEIRTypeHelperTest, CreateTypeByJavaName_PrimType) {
+  RedirectCout();
+  FEIRTypeHelper::CreateTypeByJavaName("I", false, false)->GenerateMIRType()->Dump(0);
+  EXPECT_EQ(GetBufferString(), "i32");
+  ClearBufferString();
+  FEIRTypeHelper::CreateTypeByJavaName("J", false, false)->GenerateMIRType()->Dump(0);
+  EXPECT_EQ(GetBufferString(), "i64");
+  ClearBufferString();
+  FEIRTypeHelper::CreateTypeByJavaName("F", false, false)->GenerateMIRType()->Dump(0);
+  EXPECT_EQ(GetBufferString(), "f32");
+  ClearBufferString();
+  FEIRTypeHelper::CreateTypeByJavaName("D", false, false)->GenerateMIRType()->Dump(0);
+  EXPECT_EQ(GetBufferString(), "f64");
+  ClearBufferString();
+  FEIRTypeHelper::CreateTypeByJavaName("Z", false, false)->GenerateMIRType()->Dump(0);
+  EXPECT_EQ(GetBufferString(), "u1");
+  ClearBufferString();
+  FEIRTypeHelper::CreateTypeByJavaName("B", false, false)->GenerateMIRType()->Dump(0);
+  EXPECT_EQ(GetBufferString(), "i8");
+  ClearBufferString();
+  FEIRTypeHelper::CreateTypeByJavaName("S", false, false)->GenerateMIRType()->Dump(0);
+  EXPECT_EQ(GetBufferString(), "i16");
+  ClearBufferString();
+  FEIRTypeHelper::CreateTypeByJavaName("C", false, false)->GenerateMIRType()->Dump(0);
+  EXPECT_EQ(GetBufferString(), "u16");
+  ClearBufferString();
+  FEIRTypeHelper::CreateTypeByJavaName("V", false, false)->GenerateMIRType()->Dump(0);
+  EXPECT_EQ(GetBufferString(), "void");
+  RestoreCout();
+}
+
+TEST_F(FEIRTypeHelperTest, CreateTypeByJavaName_Object) {
+  std::unique_ptr<FEIRType> type1 = FEIRTypeHelper::CreateTypeByJavaName("Ljava/lang/Object;", false, false);
+  std::unique_ptr<FEIRType> type2 = FEIRTypeHelper::CreateTypeByJavaName("Ljava/lang/Object;", false, true);
+  std::unique_ptr<FEIRType> type3 = FEIRTypeHelper::CreateTypeByJavaName("[Ljava/lang/Object;", false, false);
+  std::unique_ptr<FEIRType> type4 = FEIRTypeHelper::CreateTypeByJavaName("[Ljava/lang/Object;", false, true);
+  RedirectCout();
+  type1->GenerateMIRType()->Dump(0);
+  EXPECT_EQ(GetBufferString(), "<$Ljava_2Flang_2FObject_3B>");
+  ClearBufferString();
+  type2->GenerateMIRType()->Dump(0);
+  EXPECT_EQ(GetBufferString(), "<* <$Ljava_2Flang_2FObject_3B>>");
+  ClearBufferString();
+  type3->GenerateMIRType()->Dump(0);
+  EXPECT_EQ(GetBufferString(), "<[] <* <$Ljava_2Flang_2FObject_3B>>>");
+  ClearBufferString();
+  type4->GenerateMIRType()->Dump(0);
+  EXPECT_EQ(GetBufferString(), "<* <[] <* <$Ljava_2Flang_2FObject_3B>>>>");
+  RestoreCout();
+}
+
+TEST_F(FEIRTypeHelperTest, CreateTypeByJavaName_Undefined) {
+  std::unique_ptr<FEIRType> type1 = FEIRTypeHelper::CreateTypeByJavaName("LUndefine4FEIRTypeHelper;", false, false);
+  std::unique_ptr<FEIRType> type2 = FEIRTypeHelper::CreateTypeByJavaName("LUndefine4FEIRTypeHelper;", false, true);
+  RedirectCout();
+  type1->GenerateMIRType()->Dump(0);
+  EXPECT_EQ(GetBufferString(), "<$LUndefine4FEIRTypeHelper_3B>");
+  ClearBufferString();
+  type2->GenerateMIRType()->Dump(0);
+  EXPECT_EQ(GetBufferString(), "<* <$LUndefine4FEIRTypeHelper_3B>>");
+  RestoreCout();
+}
+
+TEST_F(FEIRTypeHelperTest, CreateTypeByDimIncr) {
+  UniqueFEIRType type1 = FEIRTypeHelper::CreateTypeByPrimType(PTY_i32, 0, false);
+  UniqueFEIRType type1A = FEIRTypeHelper::CreateTypeByDimIncr(type1, 1);
+  UniqueFEIRType type1AP = FEIRTypeHelper::CreateTypeByDimIncr(type1, 1, true);
+  UniqueFEIRType type2 = FEIRTypeHelper::CreateTypeByPrimType(PTY_i32, 1, true);
+  UniqueFEIRType type2A = FEIRTypeHelper::CreateTypeByDimIncr(type2, 2);
+  UniqueFEIRType type2AP = FEIRTypeHelper::CreateTypeByDimIncr(type2, 2, true);
+  RedirectCout();
+  type1->GenerateMIRType()->Dump(0);
+  EXPECT_EQ(GetBufferString(), "i32");
+  ClearBufferString();
+  type1A->GenerateMIRType()->Dump(0);
+  EXPECT_EQ(GetBufferString(), "<[] i32>");
+  ClearBufferString();
+  type1AP->GenerateMIRType()->Dump(0);
+  EXPECT_EQ(GetBufferString(), "<* <[] i32>>");
+  ClearBufferString();
+  type2->GenerateMIRType()->Dump(0);
+  EXPECT_EQ(GetBufferString(), "<* <[] i32>>");
+  ClearBufferString();
+  type2A->GenerateMIRType()->Dump(0);
+  EXPECT_EQ(GetBufferString(), "<* <[] <* <[] <* <[] i32>>>>>>");
+  ClearBufferString();
+  type2AP->GenerateMIRType()->Dump(0);
+  EXPECT_EQ(GetBufferString(), "<* <[] <* <[] <* <[] i32>>>>>>");
+  RestoreCout();
+}
+
+TEST_F(FEIRTypeHelperTest, CreateTypeByDimDecr) {
+  UniqueFEIRType type2AP = FEIRTypeHelper::CreateTypeByPrimType(PTY_i32, 2, true);
+  UniqueFEIRType type1AP = FEIRTypeHelper::CreateTypeByDimDecr(type2AP, 1);
+  UniqueFEIRType type0 = FEIRTypeHelper::CreateTypeByDimDecr(type2AP, 2);
+  RedirectCout();
+  type2AP->GenerateMIRType()->Dump(0);
+  EXPECT_EQ(GetBufferString(), "<* <[] <* <[] i32>>>>");
+  ClearBufferString();
+  type1AP->GenerateMIRType()->Dump(0);
+  EXPECT_EQ(GetBufferString(), "<* <[] i32>>");
+  ClearBufferString();
+  type0->GenerateMIRType()->Dump(0);
+  EXPECT_EQ(GetBufferString(), "i32");
+  RestoreCout();
+}
+
+TEST_F(FEIRTypeHelperTest, CreateTypeByGetAddress) {
+  UniqueFEIRType type0 = FEIRTypeHelper::CreateTypeByPrimType(PTY_i32, 0, false);
+  UniqueFEIRType type0P = FEIRTypeHelper::CreateTypeByGetAddress(type0);
+  RedirectCout();
+  type0->GenerateMIRType()->Dump(0);
+  EXPECT_EQ(GetBufferString(), "i32");
+  ClearBufferString();
+  type0P->GenerateMIRType()->Dump(0);
+  EXPECT_EQ(GetBufferString(), "<* i32>");
+  RestoreCout();
+}
+
+TEST_F(FEIRTypeHelperTest, CreateTypeByDereferrence) {
+  UniqueFEIRType type0P = FEIRTypeHelper::CreateTypeByPrimType(PTY_i32, 0, true);
+  UniqueFEIRType type0 = FEIRTypeHelper::CreateTypeByDereferrence(type0P);
+  RedirectCout();
+  type0P->GenerateMIRType()->Dump(0);
+  EXPECT_EQ(GetBufferString(), "<* i32>");
+  ClearBufferString();
+  type0->GenerateMIRType()->Dump(0);
+  EXPECT_EQ(GetBufferString(), "i32");
+  RestoreCout();
+}
+}  // namespace maple
\ No newline at end of file
diff --git a/src/mplfe/test/feir_type_infer_test.cpp b/src/mplfe/test/feir_type_infer_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..dcd4c16613dfc4d8ab57a1fe9c3498a5a1578ef5
--- /dev/null
+++ b/src/mplfe/test/feir_type_infer_test.cpp
@@ -0,0 +1,273 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v1 for more details.
+ */
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+#include <memory>
+#include "redirect_buffer.h"
+#include "global_tables.h"
+#include "mir_module.h"
+#include "feir_type_helper.h"
+#include "feir_type_infer.h"
+#include "feir_builder.h"
+#include "feir_var_type_scatter.h"
+#include "feir_dfg.h"
+
+namespace maple {
+class FEIRTypeHelperTest : public testing::Test, public RedirectBuffer {
+ public:
+  FEIRTypeHelperTest() = default;
+  ~FEIRTypeHelperTest() = default;
+};
+
+class FEIRTypeInferTest : public testing::Test, public RedirectBuffer {
+ public:
+  FEIRTypeInfer typeInfer;
+  FEIRTypeInferTest()
+      : typeInfer(kSrcLangJava) {}
+  ~FEIRTypeInferTest() = default;
+};
+
+TEST_F(FEIRTypeHelperTest, MergeType_Parent) {
+  UniqueFEIRType type0 = FEIRTypeHelper::CreateTypeByJavaName("Ljava/lang/Integer;", false, false);
+  UniqueFEIRType type1 = FEIRTypeHelper::CreateTypeByJavaName("Ljava/lang/Number;", false, false);
+  UniqueFEIRType type2 = FEIRTypeHelper::CreateTypeByJavaName("Ljava/lang/String;", false, false);
+  UniqueFEIRType type3 = FEIRTypeHelper::CreateTypeByJavaName("[Ljava/lang/String;", false, false);
+  UniqueFEIRType type4 = FEIRTypeHelper::CreateTypeByJavaName("I", false, false);
+  UniqueFEIRType type5 = FEIRTypeHelper::CreateTypeByJavaName("J", false, false);
+  UniqueFEIRType type6 = FEIRTypeHelper::CreateTypeByJavaName("LFEIRTypeHelperTest", false, false);
+  UniqueFEIRType typeDefault = FEIRTypeHelper::CreateTypeByJavaName("Ljava/lang/Object;", false, false);
+  UniqueFEIRType typeResult;
+  FEIRTypeMergeHelper typeMergeHelper(typeDefault);
+  // merge type0 and type1, expect Ljava/lang/Number;
+  typeResult.reset(type0->Clone().release());
+  EXPECT_EQ(typeMergeHelper.MergeType(typeResult, type1), true);
+  EXPECT_EQ(typeResult->IsEqualTo(type1), true);
+
+  // merge type1 and type0, expect Ljava/lang/Number;
+  typeResult.reset(type1->Clone().release());
+  EXPECT_EQ(typeMergeHelper.MergeType(typeResult, type0), true);
+  EXPECT_EQ(typeResult->IsEqualTo(type1), true);
+
+  // merge type0 and type2, expect Ljava/lang/Object;
+  typeResult.reset(type0->Clone().release());
+  EXPECT_EQ(typeMergeHelper.MergeType(typeResult, type2), true);
+  EXPECT_EQ(typeResult->IsEqualTo(typeDefault), true);
+
+  // merge type1 and type2, expect Ljava/lang/Object;
+  typeResult.reset(type1->Clone().release());
+  EXPECT_EQ(typeMergeHelper.MergeType(typeResult, type2), true);
+  EXPECT_EQ(typeResult->IsEqualTo(typeDefault), true);
+
+  // merge diff dim
+  typeResult.reset(type2->Clone().release());
+  EXPECT_EQ(typeMergeHelper.MergeType(typeResult, type3), false);
+
+  // merge diff PrimType
+  typeResult.reset(type4->Clone().release());
+  EXPECT_EQ(typeMergeHelper.MergeType(typeResult, type5), false);
+
+  // merge type0 and type6, expect Ljava/lang/Object;
+  typeResult.reset(type0->Clone().release());
+  EXPECT_EQ(typeMergeHelper.MergeType(typeResult, type6), true);
+  EXPECT_EQ(typeResult->IsEqualTo(typeDefault), true);
+
+  // merge type6 and type0, expect Ljava/lang/Object;
+  typeResult.reset(type6->Clone().release());
+  EXPECT_EQ(typeMergeHelper.MergeType(typeResult, type0), true);
+  EXPECT_EQ(typeResult->IsEqualTo(typeDefault), true);
+}
+
+TEST_F(FEIRTypeHelperTest, MergeType_Child) {
+  UniqueFEIRType type0 = FEIRTypeHelper::CreateTypeByJavaName("Ljava/lang/Integer;", false, false);
+  UniqueFEIRType type1 = FEIRTypeHelper::CreateTypeByJavaName("Ljava/lang/Number;", false, false);
+  UniqueFEIRType type2 = FEIRTypeHelper::CreateTypeByJavaName("Ljava/lang/String;", false, false);
+  UniqueFEIRType typeDefault = FEIRTypeHelper::CreateTypeByJavaName("Ljava/lang/Object;", false, false);
+  UniqueFEIRType typeResult;
+  FEIRTypeMergeHelper typeMergeHelper(typeDefault);
+  // merge type0 and type1, expect Ljava/lang/Integer;
+  typeResult.reset(type0->Clone().release());
+  EXPECT_EQ(typeMergeHelper.MergeType(typeResult, type1, false), true);
+  EXPECT_EQ(typeResult->IsEqualTo(type0), true);
+
+  // merge type1 and type0, expect Ljava/lang/Integer;
+  typeResult.reset(type1->Clone().release());
+  EXPECT_EQ(typeMergeHelper.MergeType(typeResult, type0, false), true);
+  EXPECT_EQ(typeResult->IsEqualTo(type0), true);
+
+  // merge type0 and type2, expect error
+  typeResult.reset(type0->Clone().release());
+  EXPECT_EQ(typeMergeHelper.MergeType(typeResult, type2, false), false);
+}
+
+//
+// TypeInferTest: Test1
+//   DFG: mplfe/doc/images/ut_cases/TypeInfer/Test1.dot
+//   Image: mplfe/doc/images/ut_cases/TypeInfer/Test1.png
+//   UseDef:
+//     var1 -> var0
+//   DefUse:
+//     var0 -> var1
+//
+TEST_F(FEIRTypeInferTest, Test1) {
+  typeInfer.Reset();
+  std::map<UniqueFEIRVar*, std::set<UniqueFEIRVar*>> mapUseDef;
+  std::map<UniqueFEIRVar*, std::set<UniqueFEIRVar*>> mapDefUse;
+  UniqueFEIRVar var0 = FEIRBuilder::CreateVarReg(0, PTY_ref, false);
+  UniqueFEIRVar var1 = FEIRBuilder::CreateVarReg(0, PTY_ref, false);
+  UniqueFEIRType type0 = FEIRTypeHelper::CreateTypeByJavaName("Ljava/lang/String;", false, true);
+  UniqueFEIRType type1 = FEIRTypeHelper::CreateTypeByJavaName("Ljava/lang/Object;", false, true);
+  var0->SetType(type0->Clone());
+  var1->SetType(type1->Clone());
+  mapUseDef[&var1].insert(&var0);
+  mapDefUse[&var0].insert(&var1);
+  typeInfer.SetMapUseDef(&mapUseDef);
+  typeInfer.SetMapDefUse(&mapDefUse);
+  EXPECT_EQ(typeInfer.GetTypeForVarUse(&var1)->IsEqualTo(type1), true);
+  typeInfer.ProcessVarDef(&var0);
+  EXPECT_EQ(var0->GetKind(), FEIRVarKind::kFEIRVarTypeScatter);
+  FEIRVarTypeScatter *ptrVar0 = static_cast<FEIRVarTypeScatter*>(var0.get());
+  EXPECT_EQ(ptrVar0->GetType()->IsEqualTo(type0), true);
+  EXPECT_EQ(ptrVar0->GetScatterTypes().size(), 1);
+  EXPECT_NE(ptrVar0->GetScatterTypes().find(FEIRTypeKey(type1)), ptrVar0->GetScatterTypes().end());
+}
+
+//
+// TypeInferTest: Test2
+//   DFG: mplfe/doc/images/ut_cases/TypeInfer/Test2.dot
+//   Image: mplfe/doc/images/ut_cases/TypeInfer/Test2.png
+//   UseDef:
+//     var1 -> var0
+//     var3 -> var2
+//   DefUse:
+//     var0 -> var1
+//     var2 -> var3
+//
+TEST_F(FEIRTypeInferTest, Test2) {
+  typeInfer.Reset();
+  std::map<UniqueFEIRVar*, std::set<UniqueFEIRVar*>> mapUseDef;
+  std::map<UniqueFEIRVar*, std::set<UniqueFEIRVar*>> mapDefUse;
+  UniqueFEIRVar var0 = FEIRBuilder::CreateVarReg(0, PTY_ref, false);
+  UniqueFEIRVar var1 = FEIRBuilder::CreateVarReg(0, PTY_ref, false);
+  UniqueFEIRVar var2 = FEIRBuilder::CreateVarReg(1, PTY_ref, false);
+  UniqueFEIRVar var3 = FEIRBuilder::CreateVarReg(1, PTY_ref, false);
+  UniqueFEIRType type0 = FEIRTypeHelper::CreateTypeByJavaName("Ljava/lang/String;", false, true);
+  UniqueFEIRType type3 = FEIRTypeHelper::CreateTypeByJavaName("Ljava/lang/Object;", false, true);
+  UniqueFEIRVarTrans trans0 = std::make_unique<FEIRVarTrans>(FEIRVarTransKind::kFEIRVarTransDirect, &var1);
+  UniqueFEIRVarTrans trans1 = std::make_unique<FEIRVarTrans>(FEIRVarTransKind::kFEIRVarTransDirect, &var2);
+  var1->SetTrans(std::move(trans1));
+  var2->SetTrans(std::move(trans0));
+  var0->SetType(type0->Clone());
+  var3->SetType(type3->Clone());
+  mapUseDef[&var1].insert(&var0);
+  mapUseDef[&var3].insert(&var2);
+  mapDefUse[&var0].insert(&var1);
+  mapDefUse[&var2].insert(&var3);
+  typeInfer.SetMapUseDef(&mapUseDef);
+  typeInfer.SetMapDefUse(&mapDefUse);
+  EXPECT_EQ(typeInfer.GetTypeForVarUse(&var1)->IsEqualTo(type3), true);
+  typeInfer.Reset();
+  EXPECT_EQ(typeInfer.GetTypeForVarUse(&var3)->IsEqualTo(type3), true);
+  typeInfer.ProcessVarDef(&var0);
+  typeInfer.ProcessVarDef(&var2);
+  EXPECT_EQ(var0->GetKind(), FEIRVarKind::kFEIRVarTypeScatter);
+  EXPECT_EQ(var2->GetKind(), FEIRVarKind::kFEIRVarReg);
+}
+
+//
+// TypeInferTest: Test3
+//   DFG: mplfe/doc/images/ut_cases/TypeInfer/Test3.dot
+//   Image: mplfe/doc/images/ut_cases/TypeInfer/Test3.png
+//   UseDef:
+//     var1 -> {var0, var5}
+//     var3 -> var2
+//     var4 -> var2
+TEST_F(FEIRTypeInferTest, Test3) {
+  typeInfer.Reset();
+  std::map<UniqueFEIRVar*, std::set<UniqueFEIRVar*>> mapUseDef;
+  std::map<UniqueFEIRVar*, std::set<UniqueFEIRVar*>> mapDefUse;
+  UniqueFEIRVar var0 = FEIRBuilder::CreateVarReg(0, PTY_ref, false);
+  UniqueFEIRVar var1 = FEIRBuilder::CreateVarReg(0, PTY_ref, false);
+  UniqueFEIRVar var2 = FEIRBuilder::CreateVarReg(1, PTY_ref, false);
+  UniqueFEIRVar var3 = FEIRBuilder::CreateVarReg(1, PTY_ref, false);
+  UniqueFEIRVar var4 = FEIRBuilder::CreateVarReg(1, PTY_ref, false);
+  UniqueFEIRVar var5 = FEIRBuilder::CreateVarReg(0, PTY_ref, false);
+  UniqueFEIRType type0 = FEIRTypeHelper::CreateTypeByJavaName("Ljava/lang/String;", false, true);
+  UniqueFEIRVarTrans trans1_2 = std::make_unique<FEIRVarTrans>(FEIRVarTransKind::kFEIRVarTransDirect, &var1);
+  UniqueFEIRVarTrans trans2_1 = std::make_unique<FEIRVarTrans>(FEIRVarTransKind::kFEIRVarTransDirect, &var2);
+  UniqueFEIRVarTrans trans4_5 = std::make_unique<FEIRVarTrans>(FEIRVarTransKind::kFEIRVarTransDirect, &var4);
+  UniqueFEIRVarTrans trans5_4 = std::make_unique<FEIRVarTrans>(FEIRVarTransKind::kFEIRVarTransDirect, &var5);
+  var1->SetTrans(std::move(trans2_1));
+  var2->SetTrans(std::move(trans1_2));
+  var4->SetTrans(std::move(trans5_4));
+  var5->SetTrans(std::move(trans4_5));
+  var3->SetType(type0->Clone());
+  mapUseDef[&var1].insert(&var0);
+  mapUseDef[&var1].insert(&var5);
+  mapUseDef[&var3].insert(&var2);
+  mapUseDef[&var4].insert(&var2);
+  FEIRDFG::CalculateDefUseByUseDef(mapDefUse, mapUseDef);
+  typeInfer.SetMapUseDef(&mapUseDef);
+  typeInfer.SetMapDefUse(&mapDefUse);
+  EXPECT_EQ(typeInfer.GetTypeForVarUse(&var1)->IsEqualTo(type0), true);
+  typeInfer.Reset();
+  EXPECT_EQ(typeInfer.GetTypeForVarUse(&var3)->IsEqualTo(type0), true);
+  typeInfer.Reset();
+  EXPECT_EQ(typeInfer.GetTypeForVarUse(&var4)->IsEqualTo(type0), true);
+  typeInfer.ProcessVarDef(&var0);
+  typeInfer.ProcessVarDef(&var2);
+  typeInfer.ProcessVarDef(&var5);
+  EXPECT_EQ(var0->GetKind(), FEIRVarKind::kFEIRVarReg);
+  EXPECT_EQ(var2->GetKind(), FEIRVarKind::kFEIRVarReg);
+  EXPECT_EQ(var5->GetKind(), FEIRVarKind::kFEIRVarReg);
+  EXPECT_EQ(var0->GetType()->IsEqualTo(type0), true);
+  EXPECT_EQ(var2->GetType()->IsEqualTo(type0), true);
+  EXPECT_EQ(var5->GetType()->IsEqualTo(type0), true);
+}
+
+//
+// TypeInferTest: Test4
+//   DFG: mplfe/doc/images/ut_cases/TypeInfer/Test4.dot
+//   Image: mplfe/doc/images/ut_cases/TypeInfer/Test4.png
+//   UseDef:
+//     var1 -> var0
+//     var3 -> var2
+//
+TEST_F(FEIRTypeInferTest, Test4) {
+  typeInfer.Reset();
+  std::map<UniqueFEIRVar*, std::set<UniqueFEIRVar*>> mapUseDef;
+  std::map<UniqueFEIRVar*, std::set<UniqueFEIRVar*>> mapDefUse;
+  UniqueFEIRVar var0 = FEIRBuilder::CreateVarReg(0, PTY_ref, false);
+  UniqueFEIRVar var1 = FEIRBuilder::CreateVarReg(0, PTY_ref, false);
+  UniqueFEIRVar var2 = FEIRBuilder::CreateVarReg(1, PTY_ref, false);
+  UniqueFEIRVar var3 = FEIRBuilder::CreateVarReg(1, PTY_ref, false);
+  UniqueFEIRType type0 = FEIRTypeHelper::CreateTypeByJavaName("Ljava/lang/Object;", false, true);
+  UniqueFEIRType type1 = FEIRTypeHelper::CreateTypeByJavaName("[Ljava/lang/Object;", false, true);
+  UniqueFEIRVarTrans trans1_2 = std::make_unique<FEIRVarTrans>(FEIRVarTransKind::kFEIRVarTransArrayDimDecr, &var1);
+  UniqueFEIRVarTrans trans2_1 = std::make_unique<FEIRVarTrans>(FEIRVarTransKind::kFEIRVarTransArrayDimIncr, &var2);
+  var3->SetType(type0->Clone());
+  var1->SetTrans(std::move(trans2_1));
+  var2->SetTrans(std::move(trans1_2));
+  mapUseDef[&var1].insert(&var0);
+  mapUseDef[&var3].insert(&var2);
+  FEIRDFG::CalculateDefUseByUseDef(mapDefUse, mapUseDef);
+  typeInfer.SetMapUseDef(&mapUseDef);
+  typeInfer.SetMapDefUse(&mapDefUse);
+  EXPECT_EQ(typeInfer.GetTypeForVarUse(&var1)->IsEqualTo(type1), true);
+  typeInfer.ProcessVarDef(&var0);
+  typeInfer.ProcessVarDef(&var2);
+  EXPECT_EQ(var0->GetType()->IsEqualTo(type1), true);
+  EXPECT_EQ(var2->GetType()->IsEqualTo(type0), true);
+}
+}  // namespace maple
diff --git a/src/mplfe/test/feir_type_test.cpp b/src/mplfe/test/feir_type_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..69709994e319efdc9d689a1804c1648828107774
--- /dev/null
+++ b/src/mplfe/test/feir_type_test.cpp
@@ -0,0 +1,290 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v1 for more details.
+ */
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+#include <unordered_set>
+#include "feir_type.h"
+#include "feir_type_helper.h"
+#include "redirect_buffer.h"
+#include "global_tables.h"
+#include "mir_module.h"
+
+namespace maple {
+class FEIRTypeDefaultTest : public testing::Test, public RedirectBuffer {
+ public:
+  FEIRTypeDefaultTest() = default;
+  ~FEIRTypeDefaultTest() = default;
+};
+
+TEST(FEIRTypeDefault, IsScalarPrimType) {
+  EXPECT_EQ(FEIRTypeDefault::IsScalarPrimType(PTY_i32), true);
+  EXPECT_EQ(FEIRTypeDefault::IsScalarPrimType(PTY_ref), false);
+}
+
+TEST_F(FEIRTypeDefaultTest, FEIRTypeDefaultTest_Ref_Array_Precise_Valid) {
+  GStrIdx idxZero = GStrIdx(0);
+  GStrIdx idxNonZero = GStrIdx(100);
+
+  FEIRTypeDefault typeScalar(PTY_i32, idxZero, 0);
+  EXPECT_EQ(typeScalar.IsRef(), false);
+  EXPECT_EQ(typeScalar.IsArray(), false);
+  EXPECT_EQ(typeScalar.IsPrecise(), true);
+  EXPECT_EQ(typeScalar.IsValid(), true);
+
+  FEIRTypeDefault typeScalarArray(PTY_i32, idxZero, 1);
+  EXPECT_EQ(typeScalarArray.IsRef(), true);
+  EXPECT_EQ(typeScalarArray.IsArray(), true);
+  EXPECT_EQ(typeScalarArray.IsPrecise(), true);
+  EXPECT_EQ(typeScalarArray.IsValid(), true);
+
+  FEIRTypeDefault typeRefNP(PTY_ref, idxZero, 0);
+  EXPECT_EQ(typeRefNP.IsRef(), true);
+  EXPECT_EQ(typeRefNP.IsArray(), false);
+  EXPECT_EQ(typeRefNP.IsPrecise(), false);
+  EXPECT_EQ(typeRefNP.IsValid(), true);
+
+  FEIRTypeDefault typeRefNPArray(PTY_ref, idxZero, 1);
+  EXPECT_EQ(typeRefNPArray.IsRef(), true);
+  EXPECT_EQ(typeRefNPArray.IsArray(), true);
+  EXPECT_EQ(typeRefNPArray.IsPrecise(), false);
+  EXPECT_EQ(typeRefNPArray.IsValid(), true);
+
+  FEIRTypeDefault typeRef(PTY_ref, idxNonZero, 0);
+  EXPECT_EQ(typeRef.IsRef(), true);
+  EXPECT_EQ(typeRef.IsArray(), false);
+  EXPECT_EQ(typeRef.IsPrecise(), true);
+  EXPECT_EQ(typeRef.IsValid(), true);
+
+  FEIRTypeDefault typeRefArray(PTY_ref, idxNonZero, 1);
+  EXPECT_EQ(typeRefArray.IsRef(), true);
+  EXPECT_EQ(typeRefArray.IsArray(), true);
+  EXPECT_EQ(typeRefArray.IsPrecise(), true);
+  EXPECT_EQ(typeRefArray.IsValid(), true);
+
+  FEIRTypeDefault typeInvalid(PTY_i32, idxNonZero, 0);
+  EXPECT_EQ(typeInvalid.IsValid(), false);
+
+  FEIRTypeDefault typeInvalidArray(PTY_i32, idxNonZero, 1);
+  EXPECT_EQ(typeInvalidArray.IsValid(), false);
+}
+
+TEST_F(FEIRTypeDefaultTest, FEIRTypeDefaultTest_default) {
+  FEIRTypeDefault type;
+  RedirectCout();
+  type.GenerateMIRType(kSrcLangJava, false)->Dump(0);
+  EXPECT_EQ(GetBufferString(), "void");
+  ClearBufferString();
+  type.GenerateMIRType(kSrcLangJava, true)->Dump(0);
+  EXPECT_EQ(GetBufferString(), "void");
+  RestoreCout();
+}
+
+TEST_F(FEIRTypeDefaultTest, FEIRTypeDefaultTest_void) {
+  FEIRTypeDefault type(PTY_void);
+  RedirectCout();
+  type.GenerateMIRType(kSrcLangJava, false)->Dump(0);
+  EXPECT_EQ(GetBufferString(), "void");
+  ClearBufferString();
+  type.GenerateMIRType(kSrcLangJava, true)->Dump(0);
+  EXPECT_EQ(GetBufferString(), "void");
+  RestoreCout();
+}
+
+TEST_F(FEIRTypeDefaultTest, FEIRTypeDefaultTest_ref) {
+  FEIRTypeDefault type(PTY_ref);
+  RedirectCout();
+  type.GenerateMIRType(kSrcLangJava, false)->Dump(0);
+  EXPECT_EQ(GetBufferString(), "ref");
+  ClearBufferString();
+  type.GenerateMIRType(kSrcLangJava, true)->Dump(0);
+  EXPECT_EQ(GetBufferString(), "ref");
+  RestoreCout();
+}
+
+TEST_F(FEIRTypeDefaultTest, FEIRTypeDefaultTest_refArray) {
+  FEIRTypeDefault type(PTY_ref, GStrIdx(0), 1);
+  RedirectCout();
+  type.GenerateMIRType(kSrcLangJava, false)->Dump(0);
+  EXPECT_EQ(GetBufferString(), "<[] ref>");
+  ClearBufferString();
+  type.GenerateMIRType(kSrcLangJava, true)->Dump(0);
+  EXPECT_EQ(GetBufferString(), "<* <[] ref>>");
+  RestoreCout();
+}
+
+TEST_F(FEIRTypeDefaultTest, FEIRTypeDefaultTest_Object) {
+  GStrIdx typeNameIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName("Ljava_2Flang_2FObject_3B");
+  FEIRTypeDefault type(PTY_ref, typeNameIdx, 0);
+  RedirectCout();
+  type.GenerateMIRType(kSrcLangJava, false)->Dump(0);
+  EXPECT_EQ(GetBufferString(), "<$Ljava_2Flang_2FObject_3B>");
+  ClearBufferString();
+  type.GenerateMIRType(kSrcLangJava, true)->Dump(0);
+  EXPECT_EQ(GetBufferString(), "<* <$Ljava_2Flang_2FObject_3B>>");
+  RestoreCout();
+}
+
+TEST_F(FEIRTypeDefaultTest, LoadFromJavaTypeName_V) {
+  FEIRTypeDefault type;
+  type.LoadFromJavaTypeName("V");
+  RedirectCout();
+  type.GenerateMIRType(kSrcLangJava, false)->Dump(0);
+  EXPECT_EQ(GetBufferString(), "void");
+  ClearBufferString();
+  type.GenerateMIRType(kSrcLangJava, true)->Dump(0);
+  EXPECT_EQ(GetBufferString(), "void");
+  RestoreCout();
+}
+
+TEST_F(FEIRTypeDefaultTest, LoadFromJavaTypeName_I) {
+  FEIRTypeDefault type;
+  type.LoadFromJavaTypeName("I");
+  RedirectCout();
+  type.GenerateMIRType(kSrcLangJava, false)->Dump(0);
+  EXPECT_EQ(GetBufferString(), "i32");
+  ClearBufferString();
+  type.GenerateMIRType(kSrcLangJava, true)->Dump(0);
+  EXPECT_EQ(GetBufferString(), "i32");
+  RestoreCout();
+}
+
+TEST_F(FEIRTypeDefaultTest, LoadFromJavaTypeName_J) {
+  FEIRTypeDefault type;
+  type.LoadFromJavaTypeName("J");
+  RedirectCout();
+  type.GenerateMIRType(kSrcLangJava, false)->Dump(0);
+  EXPECT_EQ(GetBufferString(), "i64");
+  ClearBufferString();
+  type.GenerateMIRType(kSrcLangJava, true)->Dump(0);
+  EXPECT_EQ(GetBufferString(), "i64");
+  RestoreCout();
+}
+
+TEST_F(FEIRTypeDefaultTest, LoadFromJavaTypeName_F) {
+  FEIRTypeDefault type;
+  type.LoadFromJavaTypeName("F");
+  RedirectCout();
+  type.GenerateMIRType(kSrcLangJava, false)->Dump(0);
+  EXPECT_EQ(GetBufferString(), "f32");
+  ClearBufferString();
+  type.GenerateMIRType(kSrcLangJava, true)->Dump(0);
+  EXPECT_EQ(GetBufferString(), "f32");
+  RestoreCout();
+}
+
+TEST_F(FEIRTypeDefaultTest, LoadFromJavaTypeName_D) {
+  FEIRTypeDefault type;
+  type.LoadFromJavaTypeName("D");
+  RedirectCout();
+  type.GenerateMIRType(kSrcLangJava, false)->Dump(0);
+  EXPECT_EQ(GetBufferString(), "f64");
+  ClearBufferString();
+  type.GenerateMIRType(kSrcLangJava, true)->Dump(0);
+  EXPECT_EQ(GetBufferString(), "f64");
+  RestoreCout();
+}
+
+TEST_F(FEIRTypeDefaultTest, LoadFromJavaTypeName_Z) {
+  FEIRTypeDefault type;
+  type.LoadFromJavaTypeName("Z");
+  RedirectCout();
+  type.GenerateMIRType(kSrcLangJava, false)->Dump(0);
+  EXPECT_EQ(GetBufferString(), "u1");
+  ClearBufferString();
+  type.GenerateMIRType(kSrcLangJava, true)->Dump(0);
+  EXPECT_EQ(GetBufferString(), "u1");
+  RestoreCout();
+}
+
+TEST_F(FEIRTypeDefaultTest, LoadFromJavaTypeName_B) {
+  FEIRTypeDefault type;
+  type.LoadFromJavaTypeName("B");
+  RedirectCout();
+  type.GenerateMIRType(kSrcLangJava, false)->Dump(0);
+  EXPECT_EQ(GetBufferString(), "i8");
+  ClearBufferString();
+  type.GenerateMIRType(kSrcLangJava, true)->Dump(0);
+  EXPECT_EQ(GetBufferString(), "i8");
+  RestoreCout();
+}
+
+TEST_F(FEIRTypeDefaultTest, LoadFromJavaTypeName_C) {
+  FEIRTypeDefault type;
+  type.LoadFromJavaTypeName("C");
+  RedirectCout();
+  type.GenerateMIRType(kSrcLangJava, false)->Dump(0);
+  EXPECT_EQ(GetBufferString(), "u16");
+  ClearBufferString();
+  type.GenerateMIRType(kSrcLangJava, true)->Dump(0);
+  EXPECT_EQ(GetBufferString(), "u16");
+  RestoreCout();
+}
+
+TEST_F(FEIRTypeDefaultTest, LoadFromJavaTypeName_S) {
+  FEIRTypeDefault type;
+  type.LoadFromJavaTypeName("S");
+  RedirectCout();
+  type.GenerateMIRType(kSrcLangJava, false)->Dump(0);
+  EXPECT_EQ(GetBufferString(), "i16");
+  ClearBufferString();
+  type.GenerateMIRType(kSrcLangJava, true)->Dump(0);
+  EXPECT_EQ(GetBufferString(), "i16");
+  RestoreCout();
+}
+
+TEST_F(FEIRTypeDefaultTest, LoadFromJavaTypeName_Object) {
+  FEIRTypeDefault type;
+  type.LoadFromJavaTypeName("Ljava_2Flang_2FObject_3B");
+  RedirectCout();
+  type.GenerateMIRType(kSrcLangJava, false)->Dump(0);
+  EXPECT_EQ(GetBufferString(), "<$Ljava_2Flang_2FObject_3B>");
+  ClearBufferString();
+  type.GenerateMIRType(kSrcLangJava, true)->Dump(0);
+  EXPECT_EQ(GetBufferString(), "<* <$Ljava_2Flang_2FObject_3B>>");
+  RestoreCout();
+}
+
+TEST_F(FEIRTypeDefaultTest, LoadFromJavaTypeName_AI) {
+  FEIRTypeDefault type;
+  type.LoadFromJavaTypeName("AI");
+  RedirectCout();
+  type.GenerateMIRType(kSrcLangJava, false)->Dump(0);
+  EXPECT_EQ(GetBufferString(), "<[] i32>");
+  ClearBufferString();
+  type.GenerateMIRType(kSrcLangJava, true)->Dump(0);
+  EXPECT_EQ(GetBufferString(), "<* <[] i32>>");
+  ClearBufferString();
+  type.GenerateMIRTypeAuto(kSrcLangJava)->Dump(0);
+  EXPECT_EQ(GetBufferString(), "<* <[] i32>>");
+  RestoreCout();
+}
+
+TEST_F(FEIRTypeDefaultTest, UseFEIRTypeKey) {
+  std::unordered_set<FEIRTypeKey, FEIRTypeKeyHash> testSet;
+  UniqueFEIRType type1 = FEIRTypeHelper::CreateTypeByJavaName("Ljava/lang/Object;", false, false);
+  UniqueFEIRType type2 = type1->Clone();
+  UniqueFEIRType type3 = FEIRTypeHelper::CreateTypeByJavaName("Ljava/lang/Object;", false, true);
+  UniqueFEIRType type4 = type3->Clone();
+  testSet.insert(FEIRTypeKey(type1));
+  testSet.insert(FEIRTypeKey(type2));
+  testSet.insert(FEIRTypeKey(type3));
+  testSet.insert(FEIRTypeKey(type4));
+  EXPECT_EQ(testSet.size(), 2);
+  EXPECT_NE(testSet.find(FEIRTypeKey(type1)), testSet.end());
+  EXPECT_NE(testSet.find(FEIRTypeKey(type2)), testSet.end());
+  EXPECT_NE(testSet.find(FEIRTypeKey(type3)), testSet.end());
+  EXPECT_NE(testSet.find(FEIRTypeKey(type4)), testSet.end());
+}
+}  // namespace maple
\ No newline at end of file
diff --git a/src/mplfe/test/feir_var_test.cpp b/src/mplfe/test/feir_var_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..810ee211066beb116bfe4839723d9efa9cb54ef5
--- /dev/null
+++ b/src/mplfe/test/feir_var_test.cpp
@@ -0,0 +1,187 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v1 for more details.
+ */
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+#include <memory>
+#include "feir_test_base.h"
+#include "feir_var.h"
+#include "feir_var_reg.h"
+#include "feir_var_name.h"
+#include "feir_type_helper.h"
+#include "mplfe_ut_regx.h"
+#include "feir_builder.h"
+
+namespace maple {
+class FEIRVarTest : public FEIRTestBase {
+ public:
+  FEIRVarTest() = default;
+  virtual ~FEIRVarTest() = default;
+};
+
+TEST_F(FEIRVarTest, FEIRVarReg) {
+  std::unique_ptr<FEIRType> type = FEIRTypeHelper::CreateTypeByJavaName("Ljava/lang/Object;", false, true);
+  FEIRVarReg varReg(1, std::move(type));
+  varReg.SetGlobal(false);
+  MIRSymbol *symbol = varReg.GenerateMIRSymbol(mirBuilder);
+  RedirectCout();
+  std::string symbolName = symbol->GetName();
+  std::string strPattern = MPLFEUTRegx::RegName(1) + "_" + MPLFEUTRegx::RefIndex(MPLFEUTRegx::kAnyNumber);
+  EXPECT_EQ(MPLFEUTRegx::Match(symbolName, strPattern), true);
+  symbol->Dump(true, 0);
+  std::string symbolDump = GetBufferString();
+  std::string strPattern2 = "var %" + MPLFEUTRegx::RegName(1) + "_" + MPLFEUTRegx::RefIndex(MPLFEUTRegx::kAnyNumber) +
+                            MPLFEUTRegx::Any();
+  EXPECT_EQ(MPLFEUTRegx::Match(symbolDump, strPattern2), true);
+  RestoreCout();
+}
+
+TEST_F(FEIRVarTest, FEIRVarName) {
+  std::unique_ptr<FEIRType> type = FEIRTypeHelper::CreateTypeByJavaName("Ljava/lang/Object;", false, true);
+  GStrIdx nameIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName("Ljava_2Flang_2FObject_3B_7Cklass");
+  FEIRVarName varName(nameIdx, std::move(type));
+  varName.SetGlobal(true);
+  MIRSymbol *symbol = varName.GenerateMIRSymbol(mirBuilder);
+  RedirectCout();
+  std::string symbolName = symbol->GetName();
+  EXPECT_EQ(symbolName, "Ljava_2Flang_2FObject_3B_7Cklass");
+  symbol->Dump(false, 0);
+  std::string symbolDump = GetBufferString();
+  std::string strPattern2 = std::string("var \\$") + "Ljava_2Flang_2FObject_3B_7Cklass" + MPLFEUTRegx::Any();
+  EXPECT_EQ(MPLFEUTRegx::Match(symbolDump, strPattern2), true);
+  RestoreCout();
+}
+
+TEST_F(FEIRVarTest, FEIRVarTransDirect) {
+  UniqueFEIRVar var = FEIRBuilder::CreateVarReg(0, PTY_ref, false);
+  FEIRVarTrans trans(FEIRVarTransKind::kFEIRVarTransDirect, var);
+  RedirectCout();
+  UniqueFEIRType type1 = FEIRTypeHelper::CreateTypeByJavaName("Ljava/lang/Object;", false, false);
+  UniqueFEIRType type1T = trans.GetType(type1);
+  type1T->GenerateMIRType()->Dump(0);
+  EXPECT_EQ(GetBufferString(), "<$Ljava_2Flang_2FObject_3B>");
+  ClearBufferString();
+
+  UniqueFEIRType type2 = FEIRTypeHelper::CreateTypeByJavaName("Ljava/lang/Object;", false, true);
+  UniqueFEIRType type2T = trans.GetType(type2);
+  type2T->GenerateMIRType()->Dump(0);
+  EXPECT_EQ(GetBufferString(), "<* <$Ljava_2Flang_2FObject_3B>>");
+  ClearBufferString();
+
+  UniqueFEIRType type3 = FEIRTypeHelper::CreateTypeByJavaName("I", false, false);
+  UniqueFEIRType type3T = trans.GetType(type3);
+  type3T->GenerateMIRType()->Dump(0);
+  EXPECT_EQ(GetBufferString(), "i32");
+  ClearBufferString();
+
+  UniqueFEIRType type4 = FEIRTypeHelper::CreateTypeByJavaName("[I", false, true);
+  UniqueFEIRType type4T = trans.GetType(type4);
+  type4T->GenerateMIRType()->Dump(0);
+  EXPECT_EQ(GetBufferString(), "<* <[] i32>>");
+  ClearBufferString();
+  RestoreCout();
+}
+
+TEST_F(FEIRVarTest, FEIRVarTransArrayDimIncr) {
+  UniqueFEIRVar var = FEIRBuilder::CreateVarReg(0, PTY_ref, false);
+  FEIRVarTrans trans(FEIRVarTransKind::kFEIRVarTransArrayDimIncr, var);
+  RedirectCout();
+  UniqueFEIRType type1 = FEIRTypeHelper::CreateTypeByJavaName("Ljava/lang/Object;", false, false);
+  UniqueFEIRType type1T = trans.GetType(type1);
+  UniqueFEIRType type1T2 = trans.GetType(type1, PTY_ref, false);
+  type1T->GenerateMIRType()->Dump(0);
+  EXPECT_EQ(GetBufferString(), "<* <[] <* <$Ljava_2Flang_2FObject_3B>>>>");
+  ClearBufferString();
+  type1T2->GenerateMIRType()->Dump(0);
+  EXPECT_EQ(GetBufferString(), "<[] <* <$Ljava_2Flang_2FObject_3B>>>");
+  ClearBufferString();
+
+  UniqueFEIRType type2 = FEIRTypeHelper::CreateTypeByJavaName("[Ljava/lang/Object;", false, true);
+  UniqueFEIRType type2T = trans.GetType(type2);
+  UniqueFEIRType type2T2 = trans.GetType(type2, PTY_ref, false);
+  type2T->GenerateMIRType()->Dump(0);
+  EXPECT_EQ(GetBufferString(), "<* <[] <* <[] <* <$Ljava_2Flang_2FObject_3B>>>>>>");
+  ClearBufferString();
+  type2T2->GenerateMIRType()->Dump(0);
+  EXPECT_EQ(GetBufferString(), "<* <[] <* <[] <* <$Ljava_2Flang_2FObject_3B>>>>>>");
+  ClearBufferString();
+
+  UniqueFEIRType type3 = FEIRTypeHelper::CreateTypeByJavaName("I", false, false);
+  UniqueFEIRType type3T = trans.GetType(type3);
+  UniqueFEIRType type3T2 = trans.GetType(type3, PTY_ref, false);
+  type3T->GenerateMIRType()->Dump(0);
+  EXPECT_EQ(GetBufferString(), "<* <[] i32>>");
+  ClearBufferString();
+  type3T2->GenerateMIRType()->Dump(0);
+  EXPECT_EQ(GetBufferString(), "<[] i32>");
+  ClearBufferString();
+
+  UniqueFEIRType type4 = FEIRTypeHelper::CreateTypeByJavaName("[I", false, true);
+  UniqueFEIRType type4T = trans.GetType(type4);
+  UniqueFEIRType type4T2 = trans.GetType(type4, PTY_ref, false);
+  type4T->GenerateMIRType()->Dump(0);
+  EXPECT_EQ(GetBufferString(), "<* <[] <* <[] i32>>>>");
+  ClearBufferString();
+  type4T2->GenerateMIRType()->Dump(0);
+  EXPECT_EQ(GetBufferString(), "<* <[] <* <[] i32>>>>");
+  ClearBufferString();
+  RestoreCout();
+}
+
+TEST_F(FEIRVarTest, FEIRVarTransArrayDimDecr) {
+  UniqueFEIRVar var = FEIRBuilder::CreateVarReg(0, PTY_ref, false);
+  FEIRVarTrans trans(FEIRVarTransKind::kFEIRVarTransArrayDimDecr, var);
+  RedirectCout();
+  UniqueFEIRType type1 = FEIRTypeHelper::CreateTypeByJavaName("[Ljava/lang/Object;", false, false);
+  UniqueFEIRType type1T = trans.GetType(type1);
+  UniqueFEIRType type1T2 = trans.GetType(type1, PTY_ref, false);
+  type1T->GenerateMIRType()->Dump(0);
+  EXPECT_EQ(GetBufferString(), "<* <$Ljava_2Flang_2FObject_3B>>");
+  ClearBufferString();
+  type1T2->GenerateMIRType()->Dump(0);
+  EXPECT_EQ(GetBufferString(), "<$Ljava_2Flang_2FObject_3B>");
+  ClearBufferString();
+
+  UniqueFEIRType type2 = FEIRTypeHelper::CreateTypeByJavaName("[[Ljava/lang/Object;", false, true);
+  UniqueFEIRType type2T = trans.GetType(type2);
+  UniqueFEIRType type2T2 = trans.GetType(type2, PTY_ref, false);
+  type2T->GenerateMIRType()->Dump(0);
+  EXPECT_EQ(GetBufferString(), "<* <[] <* <$Ljava_2Flang_2FObject_3B>>>>");
+  ClearBufferString();
+  type2T2->GenerateMIRType()->Dump(0);
+  EXPECT_EQ(GetBufferString(), "<* <[] <* <$Ljava_2Flang_2FObject_3B>>>>");
+  ClearBufferString();
+
+  UniqueFEIRType type3 = FEIRTypeHelper::CreateTypeByJavaName("[I", false, false);
+  UniqueFEIRType type3T = trans.GetType(type3);
+  UniqueFEIRType type3T2 = trans.GetType(type3, PTY_ref, false);
+  type3T->GenerateMIRType()->Dump(0);
+  EXPECT_EQ(GetBufferString(), "i32");
+  ClearBufferString();
+  type3T2->GenerateMIRType()->Dump(0);
+  EXPECT_EQ(GetBufferString(), "i32");
+  ClearBufferString();
+
+  UniqueFEIRType type4 = FEIRTypeHelper::CreateTypeByJavaName("[[I", false, false);
+  UniqueFEIRType type4T = trans.GetType(type4);
+  UniqueFEIRType type4T2 = trans.GetType(type4, PTY_ref, false);
+  type4T->GenerateMIRType()->Dump(0);
+  EXPECT_EQ(GetBufferString(), "<* <[] i32>>");
+  ClearBufferString();
+  type4T2->GenerateMIRType()->Dump(0);
+  EXPECT_EQ(GetBufferString(), "<[] i32>");
+  ClearBufferString();
+  RestoreCout();
+}
+}  // namespace maple
\ No newline at end of file
diff --git a/src/mplfe/test/jbc_class2fe_helper_test.cpp b/src/mplfe/test/jbc_class2fe_helper_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..cac4e3670668e211127ba54f9c8ca02f1e573daa
--- /dev/null
+++ b/src/mplfe/test/jbc_class2fe_helper_test.cpp
@@ -0,0 +1,429 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v1 for more details.
+ */
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+#include <climits>
+#define protected public
+#define private public
+#include "jbc_class2fe_helper.h"
+#undef protected
+#undef private
+#include "redirect_buffer.h"
+#include "fe_options.h"
+
+namespace maple {
+class JBCClass2FEHelperTest : public testing::Test, public RedirectBuffer {
+ public:
+  JBCClass2FEHelperTest()
+      : allocator(mp) {}
+  ~JBCClass2FEHelperTest() = default;
+
+  static void SetUpTestCase() {
+    mp = memPoolCtrler.NewMemPool("MemPool for JBCClass2FEHelperTest");
+  }
+
+  static void TearDownTestCase() {
+    memPoolCtrler.DeleteMemPool(mp);
+    mp = nullptr;
+  }
+
+ protected:
+  static MemPool *mp;
+  MapleAllocator allocator;
+};
+MemPool *JBCClass2FEHelperTest::mp = nullptr;
+
+class JBCClassField2FEHelperTest : public testing::Test, public RedirectBuffer {
+ public:
+  JBCClassField2FEHelperTest()
+      : allocator(mp) {}
+  ~JBCClassField2FEHelperTest() = default;
+
+  static void SetUpTestCase() {
+    mp = memPoolCtrler.NewMemPool("MemPool for JBCClassField2FEHelperTest");
+  }
+
+  static void TearDownTestCase() {
+    memPoolCtrler.DeleteMemPool(mp);
+    mp = nullptr;
+  }
+
+ protected:
+  static MemPool *mp;
+  MapleAllocator allocator;
+};
+MemPool *JBCClassField2FEHelperTest::mp = nullptr;
+
+class MockJBCClass : public jbc::JBCClass {
+ public:
+  explicit MockJBCClass(MapleAllocator &allocator) : jbc::JBCClass(allocator) {}
+  ~MockJBCClass() = default;
+  MOCK_CONST_METHOD0(GetClassNameMpl, std::string());
+  MOCK_CONST_METHOD0(GetClassNameOrin, std::string());
+  MOCK_CONST_METHOD0(GetSuperClassName, std::string());
+  MOCK_CONST_METHOD0(GetInterfaceNames, std::vector<std::string>());
+};
+
+class MockJBCClassField : public jbc::JBCClassField {
+ public:
+  MockJBCClassField(MapleAllocator &allocator, const jbc::JBCClass &klass)
+      : jbc::JBCClassField(allocator, klass) {}
+  ~MockJBCClassField() = default;
+  MOCK_CONST_METHOD0(GetAccessFlag, uint16());
+  MOCK_CONST_METHOD0(IsStatic, bool());
+  MOCK_CONST_METHOD1(GetName, std::string(const jbc::JBCConstPool&));
+  MOCK_CONST_METHOD1(GetDescription, std::string(const jbc::JBCConstPool&));
+};
+
+class MockJBCClass2FEHelper : public JBCClass2FEHelper {
+ public:
+  MockJBCClass2FEHelper(MapleAllocator &allocator, jbc::JBCClass &klassIn)
+      : JBCClass2FEHelper(allocator, klassIn) {}
+  ~MockJBCClass2FEHelper() = default;
+  MOCK_CONST_METHOD0(IsStaticFieldProguard, bool());
+};
+
+TEST_F(JBCClass2FEHelperTest, PreProcessDecl_SameName) {
+  MockJBCClass *klass = mp->New<MockJBCClass>(allocator);
+  JBCClass2FEHelper helper(allocator, *klass);
+  EXPECT_CALL(*klass, GetClassNameMpl())
+      .Times(1000)
+      .WillRepeatedly(::testing::Return("Ljava_2Flang_2FObject_3B"));
+  EXPECT_CALL(*klass, GetClassNameOrin())
+      .Times(1000)
+      .WillRepeatedly(::testing::Return("Ljava/lang/Object;"));
+  helper.PreProcessDecl();
+  EXPECT_EQ(helper.IsSkipped(), true);
+}
+
+TEST_F(JBCClass2FEHelperTest, PreProcessDecl_NotSameName_Class) {
+  MockJBCClass *klass = mp->New<MockJBCClass>(allocator);
+  JBCClass2FEHelper helper(allocator, *klass);
+  EXPECT_CALL(*klass, GetClassNameMpl())
+      .Times(1000)
+      .WillRepeatedly(::testing::Return("LNewClass1InJBCClass2FEHelperTest_3B"));
+  EXPECT_CALL(*klass, GetClassNameOrin())
+      .Times(1000)
+      .WillRepeatedly(::testing::Return("LNewClass1InJBCClass2FEHelperTest;"));
+  helper.PreProcessDecl();
+  EXPECT_EQ(helper.IsSkipped(), false);
+}
+
+TEST_F(JBCClass2FEHelperTest, PreProcessDecl_NotSameName_Interface) {
+  MockJBCClass *klass = mp->New<MockJBCClass>(allocator);
+  JBCClass2FEHelper helper(allocator, *klass);
+  EXPECT_CALL(*klass, GetClassNameMpl())
+      .Times(1000)
+      .WillRepeatedly(::testing::Return("LNewInterface1InJBCClass2FEHelperTest_3B"));
+  EXPECT_CALL(*klass, GetClassNameOrin())
+      .Times(1000)
+      .WillRepeatedly(::testing::Return("LNewInterface1InJBCClass2FEHelperTest;"));
+  klass->header.accessFlag = jbc::kAccClassInterface;
+  helper.PreProcessDecl();
+  EXPECT_EQ(helper.IsSkipped(), false);
+}
+
+TEST_F(JBCClass2FEHelperTest, ProcessDeclSuperClassForClass) {
+  MockJBCClass *klass = mp->New<MockJBCClass>(allocator);
+  JBCClass2FEHelper helper(allocator, *klass);
+  EXPECT_CALL(*klass, GetClassNameMpl())
+      .Times(1000)
+      .WillRepeatedly(::testing::Return("LNewClass2InJBCClass2FEHelperTest_3B"));
+  EXPECT_CALL(*klass, GetClassNameOrin())
+      .Times(1000)
+      .WillRepeatedly(::testing::Return("LNewClass2InJBCClass2FEHelperTest;"));
+  EXPECT_CALL(*klass, GetSuperClassName())
+      .Times(1000)
+      .WillRepeatedly(::testing::Return("Ljava/lang/Object;"));
+  helper.PreProcessDecl();
+  helper.ProcessDeclSuperClass();
+  MIRStructType *structType = helper.GetContainer();
+  EXPECT_NE(structType, nullptr);
+  EXPECT_EQ(structType->GetKind(), kTypeClass);
+  MIRClassType *classType = static_cast<MIRClassType*>(structType);
+  MIRType *superType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(classType->GetParentTyIdx());
+  EXPECT_EQ(superType->GetKind(), kTypeClass);
+  EXPECT_EQ(superType->GetCompactMplTypeName(), "Ljava_2Flang_2FObject_3B");
+}
+
+TEST_F(JBCClass2FEHelperTest, ProcessDeclImplementsForClass) {
+  MockJBCClass *klass = mp->New<MockJBCClass>(allocator);
+  JBCClass2FEHelper helper(allocator, *klass);
+  EXPECT_CALL(*klass, GetClassNameMpl())
+      .Times(1000)
+      .WillRepeatedly(::testing::Return("LNewClass3InJBCClass2FEHelperTest_3B"));
+  EXPECT_CALL(*klass, GetClassNameOrin())
+      .Times(1000)
+      .WillRepeatedly(::testing::Return("LNewClass3InJBCClass2FEHelperTest;"));
+  EXPECT_CALL(*klass, GetInterfaceNames())
+      .Times(1000)
+      .WillRepeatedly(::testing::Return(std::vector<std::string>({ "LTestInterface1;", "LTestInterface2;" })));
+  helper.PreProcessDecl();
+  helper.ProcessDeclImplements();
+  MIRStructType *structType = helper.GetContainer();
+  EXPECT_NE(structType, nullptr);
+  EXPECT_EQ(structType->GetKind(), kTypeClass);
+  MIRClassType *classType = static_cast<MIRClassType*>(structType);
+  const std::vector<TyIdx> &interfaces = classType->GetInterfaceImplemented();
+  EXPECT_EQ(interfaces.size(), 2);
+  MIRType *interfaceType0 = GlobalTables::GetTypeTable().GetTypeFromTyIdx(interfaces[0]);
+  EXPECT_EQ(interfaceType0->GetKind(), kTypeInterfaceIncomplete);
+  EXPECT_EQ(interfaceType0->GetCompactMplTypeName(), "LTestInterface1_3B");
+  MIRType *interfaceType1 = GlobalTables::GetTypeTable().GetTypeFromTyIdx(interfaces[1]);
+  EXPECT_EQ(interfaceType1->GetKind(), kTypeInterfaceIncomplete);
+  EXPECT_EQ(interfaceType1->GetCompactMplTypeName(), "LTestInterface2_3B");
+}
+
+TEST_F(JBCClass2FEHelperTest, ProcessDeclSuperClassForInterface) {
+  MockJBCClass *klass = mp->New<MockJBCClass>(allocator);
+  klass->header.accessFlag = jbc::kAccClassInterface;
+  JBCClass2FEHelper helper(allocator, *klass);
+  EXPECT_CALL(*klass, GetClassNameMpl())
+      .Times(1000)
+      .WillRepeatedly(::testing::Return("LNewInterface2InJBCClass2FEHelperTest_3B"));
+  EXPECT_CALL(*klass, GetClassNameOrin())
+      .Times(1000)
+      .WillRepeatedly(::testing::Return("LNewInterface2InJBCClass2FEHelperTest;"));
+  EXPECT_CALL(*klass, GetSuperClassName())
+      .Times(1000)
+      .WillRepeatedly(::testing::Return("Ljava/io/Serializable;"));
+  helper.PreProcessDecl();
+  helper.ProcessDeclSuperClass();
+  MIRStructType *structType = helper.GetContainer();
+  EXPECT_NE(structType, nullptr);
+  EXPECT_EQ(structType->GetKind(), kTypeInterface);
+  MIRInterfaceType *interfaceType = static_cast<MIRInterfaceType*>(structType);
+  const std::vector<TyIdx> &parents = interfaceType->GetParentsTyIdx();
+  ASSERT_EQ(parents.size(), 1);
+  MIRType *interfaceType0 = GlobalTables::GetTypeTable().GetTypeFromTyIdx(parents[0]);
+  EXPECT_EQ(interfaceType0->GetKind(), kTypeInterface);
+  EXPECT_EQ(interfaceType0->GetCompactMplTypeName(), "Ljava_2Fio_2FSerializable_3B");
+}
+
+TEST_F(JBCClass2FEHelperTest, ProcessDeclImplementsForInterface) {
+  MockJBCClass *klass = mp->New<MockJBCClass>(allocator);
+  klass->header.accessFlag = jbc::kAccClassInterface;
+  JBCClass2FEHelper helper(allocator, *klass);
+  EXPECT_CALL(*klass, GetClassNameMpl())
+      .Times(1000)
+      .WillRepeatedly(::testing::Return("LNewInterface3InJBCClass2FEHelperTest_3B"));
+  EXPECT_CALL(*klass, GetClassNameOrin())
+      .Times(1000)
+      .WillRepeatedly(::testing::Return("LNewInterface3InJBCClass2FEHelperTest;"));
+  EXPECT_CALL(*klass, GetInterfaceNames())
+      .Times(1000)
+      .WillRepeatedly(::testing::Return(std::vector<std::string>({ "LTestInterface3;", "LTestInterface4;" })));
+  helper.PreProcessDecl();
+  helper.ProcessDeclImplements();
+  MIRStructType *structType = helper.GetContainer();
+  EXPECT_NE(structType, nullptr);
+  EXPECT_EQ(structType->GetKind(), kTypeInterface);
+  MIRInterfaceType *interfaceType = static_cast<MIRInterfaceType*>(structType);
+  const std::vector<TyIdx> &parents = interfaceType->GetParentsTyIdx();
+  EXPECT_EQ(parents.size(), 2);
+  MIRType *interfaceType0 = GlobalTables::GetTypeTable().GetTypeFromTyIdx(parents[0]);
+  EXPECT_EQ(interfaceType0->GetKind(), kTypeInterfaceIncomplete);
+  EXPECT_EQ(interfaceType0->GetCompactMplTypeName(), "LTestInterface3_3B");
+  MIRType *interfaceType1 = GlobalTables::GetTypeTable().GetTypeFromTyIdx(parents[1]);
+  EXPECT_EQ(interfaceType1->GetKind(), kTypeInterfaceIncomplete);
+  EXPECT_EQ(interfaceType1->GetCompactMplTypeName(), "LTestInterface4_3B");
+}
+
+TEST_F(JBCClass2FEHelperTest, CreateSymbol_Class) {
+  MockJBCClass *klass = mp->New<MockJBCClass>(allocator);
+  JBCClass2FEHelper helper(allocator, *klass);
+  EXPECT_CALL(*klass, GetClassNameMpl())
+      .Times(1000)
+      .WillRepeatedly(::testing::Return("LNewClass4InJBCClass2FEHelperTest_3B"));
+  EXPECT_CALL(*klass, GetClassNameOrin())
+      .Times(1000)
+      .WillRepeatedly(::testing::Return("LNewClass4InJBCClass2FEHelperTest;"));
+  helper.PreProcessDecl();
+  helper.CreateSymbol();
+  EXPECT_NE(helper.mirSymbol, nullptr);
+  RedirectCout();
+  helper.mirSymbol->Dump(false, 0);
+  EXPECT_EQ(GetBufferString(),
+      "javaclass $LNewClass4InJBCClass2FEHelperTest_3B <$LNewClass4InJBCClass2FEHelperTest_3B>\n");
+  RestoreCout();
+}
+
+TEST_F(JBCClass2FEHelperTest, CreateSymbol_Interface) {
+  MockJBCClass *klass = mp->New<MockJBCClass>(allocator);
+  JBCClass2FEHelper helper(allocator, *klass);
+  EXPECT_CALL(*klass, GetClassNameMpl())
+      .Times(1000)
+      .WillRepeatedly(::testing::Return("LNewInterface4InJBCClass2FEHelperTest_3B"));
+  EXPECT_CALL(*klass, GetClassNameOrin())
+      .Times(1000)
+      .WillRepeatedly(::testing::Return("LNewInterface4InJBCClass2FEHelperTest;"));
+  klass->header.accessFlag = jbc::kAccClassInterface;
+  helper.PreProcessDecl();
+  helper.CreateSymbol();
+  EXPECT_NE(helper.mirSymbol, nullptr);
+  RedirectCout();
+  helper.mirSymbol->Dump(false, 0);
+  EXPECT_EQ(GetBufferString(),
+      "javainterface $LNewInterface4InJBCClass2FEHelperTest_3B <$LNewInterface4InJBCClass2FEHelperTest_3B>\n");
+  RestoreCout();
+}
+
+TEST_F(JBCClass2FEHelperTest, ProcessDecl_Class) {
+  MockJBCClass *klass = mp->New<MockJBCClass>(allocator);
+  klass->header.accessFlag = jbc::kAccClassAbstract;
+  JBCClass2FEHelper helper(allocator, *klass);
+  EXPECT_CALL(*klass, GetClassNameMpl())
+      .Times(1000)
+      .WillRepeatedly(::testing::Return("LNewClass5InJBCClass2FEHelperTest_3B"));
+  EXPECT_CALL(*klass, GetClassNameOrin())
+      .Times(1000)
+      .WillRepeatedly(::testing::Return("LNewClass5InJBCClass2FEHelperTest;"));
+  EXPECT_CALL(*klass, GetSuperClassName())
+      .Times(1000)
+      .WillRepeatedly(::testing::Return("Ljava/lang/Object;"));
+  EXPECT_CALL(*klass, GetInterfaceNames())
+      .Times(1000)
+      .WillRepeatedly(::testing::Return(std::vector<std::string>()));
+  helper.PreProcessDecl();
+  helper.ProcessDecl();
+  EXPECT_NE(helper.mirSymbol, nullptr);
+  RedirectCout();
+  helper.mirSymbol->Dump(false, 0);
+  EXPECT_EQ(GetBufferString(),
+      "javaclass $LNewClass5InJBCClass2FEHelperTest_3B <$LNewClass5InJBCClass2FEHelperTest_3B> abstract\n");
+  RestoreCout();
+}
+
+TEST_F(JBCClass2FEHelperTest, ProcessDecl_Interface) {
+  MockJBCClass *klass = mp->New<MockJBCClass>(allocator);
+  klass->header.accessFlag = jbc::kAccClassInterface | jbc::kAccClassPublic;
+  JBCClass2FEHelper helper(allocator, *klass);
+  EXPECT_CALL(*klass, GetClassNameMpl())
+      .Times(1000)
+      .WillRepeatedly(::testing::Return("LNewInterface5InJBCClass2FEHelperTest_3B"));
+  EXPECT_CALL(*klass, GetClassNameOrin())
+      .Times(1000)
+      .WillRepeatedly(::testing::Return("LNewInterface5InJBCClass2FEHelperTest;"));
+  EXPECT_CALL(*klass, GetSuperClassName())
+      .Times(1000)
+      .WillRepeatedly(::testing::Return("Ljava/lang/Object;"));
+  EXPECT_CALL(*klass, GetInterfaceNames())
+      .Times(1000)
+      .WillRepeatedly(::testing::Return(std::vector<std::string>()));
+  helper.PreProcessDecl();
+  helper.ProcessDecl();
+  EXPECT_NE(helper.mirSymbol, nullptr);
+  RedirectCout();
+  helper.mirSymbol->Dump(false, 0);
+  EXPECT_EQ(GetBufferString(),
+      "javainterface $LNewInterface5InJBCClass2FEHelperTest_3B <$LNewInterface5InJBCClass2FEHelperTest_3B> public\n");
+  RestoreCout();
+}
+
+TEST_F(JBCClassField2FEHelperTest, ProcessDeclWithContainer_Instance) {
+  MockJBCClass *klass = mp->New<MockJBCClass>(allocator);
+  EXPECT_CALL(*klass, GetClassNameOrin()).Times(1000)
+      .WillRepeatedly(::testing::Return("LTestPack/TestClass;"));
+  MockJBCClassField *field = mp->New<MockJBCClassField>(allocator, *klass);
+  EXPECT_CALL(*field, GetAccessFlag()).Times(1).WillOnce(::testing::Return(jbc::kAccFieldPublic));
+  EXPECT_CALL(*field, IsStatic()).Times(100).WillRepeatedly(::testing::Return(false));
+  EXPECT_CALL(*field, GetName(::testing::_)).Times(1).WillOnce(::testing::Return("field"));
+  EXPECT_CALL(*field, GetDescription(::testing::_)).Times(1).WillOnce(::testing::Return("Ljava/lang/Object;"));
+  JBCClass2FEHelper klassHelper(allocator, *klass);
+  JBCClassField2FEHelper fieldHelper(allocator, *field);
+  ASSERT_EQ(fieldHelper.ProcessDeclWithContainer(allocator, klassHelper), true);
+  // check field name
+  std::string fieldName = GlobalTables::GetStrTable().GetStringFromStrIdx(fieldHelper.mirFieldPair.first);
+  EXPECT_EQ(fieldName, "field");
+  // check field type
+  MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(fieldHelper.mirFieldPair.second.first);
+  EXPECT_EQ(type->GetKind(), kTypePointer);
+  EXPECT_EQ(type->GetCompactMplTypeName(), "Ljava_2Flang_2FObject_3B");
+  // check field attr
+  EXPECT_EQ(fieldHelper.mirFieldPair.second.second.GetAttr(FLDATTR_public), true);
+}
+
+TEST_F(JBCClassField2FEHelperTest, ProcessDeclWithContainer_Static) {
+  MockJBCClass *klass = mp->New<MockJBCClass>(allocator);
+  EXPECT_CALL(*klass, GetClassNameOrin()).Times(1000)
+      .WillRepeatedly(::testing::Return("LTestPack/TestClass;"));
+  MockJBCClassField *field = mp->New<MockJBCClassField>(allocator, *klass);
+  EXPECT_CALL(*field, GetAccessFlag()).Times(1).WillOnce(::testing::Return(jbc::kAccFieldProtected));
+  EXPECT_CALL(*field, IsStatic()).Times(100).WillRepeatedly(::testing::Return(true));
+  EXPECT_CALL(*field, GetName(::testing::_)).Times(1).WillOnce(::testing::Return("field_static"));
+  EXPECT_CALL(*field, GetDescription(::testing::_)).Times(1).WillOnce(::testing::Return("Ljava/lang/Object;"));
+  JBCClass2FEHelper klassHelper(allocator, *klass);
+  JBCClassField2FEHelper fieldHelper(allocator, *field);
+  ASSERT_EQ(fieldHelper.ProcessDeclWithContainer(allocator, klassHelper), true);
+  // check field name
+  std::string fieldName = GlobalTables::GetStrTable().GetStringFromStrIdx(fieldHelper.mirFieldPair.first);
+  EXPECT_EQ(fieldName, "LTestPack_2FTestClass_3B_7Cfield__static");
+  // check field type
+  MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(fieldHelper.mirFieldPair.second.first);
+  EXPECT_EQ(type->GetKind(), kTypePointer);
+  EXPECT_EQ(type->GetCompactMplTypeName(), "Ljava_2Flang_2FObject_3B");
+  // check field attr
+  EXPECT_EQ(fieldHelper.mirFieldPair.second.second.GetAttr(FLDATTR_protected), true);
+}
+
+TEST_F(JBCClassField2FEHelperTest, ProcessDeclWithContainer_Static_AllType) {
+  MockJBCClass *klass = mp->New<MockJBCClass>(allocator);
+  EXPECT_CALL(*klass, GetClassNameOrin()).Times(1000)
+      .WillRepeatedly(::testing::Return("LTestPack/TestClass;"));
+  MockJBCClassField *field = mp->New<MockJBCClassField>(allocator, *klass);
+  EXPECT_CALL(*field, GetAccessFlag()).Times(1).WillOnce(::testing::Return(jbc::kAccFieldPrivate));
+  EXPECT_CALL(*field, IsStatic()).Times(100).WillRepeatedly(::testing::Return(true));
+  EXPECT_CALL(*field, GetName(::testing::_)).Times(1).WillOnce(::testing::Return("field_static"));
+  EXPECT_CALL(*field, GetDescription(::testing::_)).Times(1).WillOnce(::testing::Return("Ljava/lang/Object;"));
+  JBCClass2FEHelper klassHelper(allocator, *klass);
+  FEOptions::GetInstance().SetModeJavaStaticFieldName(FEOptions::kAllType);
+  JBCClassField2FEHelper fieldHelper(allocator, *field);
+  ASSERT_EQ(fieldHelper.ProcessDeclWithContainer(allocator, klassHelper), true);
+  // check field name
+  std::string fieldName = GlobalTables::GetStrTable().GetStringFromStrIdx(fieldHelper.mirFieldPair.first);
+  EXPECT_EQ(fieldName, "LTestPack_2FTestClass_3B_7Cfield__static_7CLjava_2Flang_2FObject_3B");
+  // check field type
+  MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(fieldHelper.mirFieldPair.second.first);
+  EXPECT_EQ(type->GetKind(), kTypePointer);
+  EXPECT_EQ(type->GetCompactMplTypeName(), "Ljava_2Flang_2FObject_3B");
+  // check field attr
+  EXPECT_EQ(fieldHelper.mirFieldPair.second.second.GetAttr(FLDATTR_private), true);
+}
+
+TEST_F(JBCClassField2FEHelperTest, ProcessDeclWithContainer_Static_Smart) {
+  MockJBCClass *klass = mp->New<MockJBCClass>(allocator);
+  EXPECT_CALL(*klass, GetClassNameOrin()).Times(1000)
+      .WillRepeatedly(::testing::Return("LTestPack/TestClass;"));
+  MockJBCClassField *field = mp->New<MockJBCClassField>(allocator, *klass);
+  EXPECT_CALL(*field, GetAccessFlag()).Times(1).WillOnce(::testing::Return(jbc::kAccFieldPrivate));
+  EXPECT_CALL(*field, IsStatic()).Times(100).WillRepeatedly(::testing::Return(true));
+  EXPECT_CALL(*field, GetName(::testing::_)).Times(1).WillOnce(::testing::Return("field_static"));
+  EXPECT_CALL(*field, GetDescription(::testing::_)).Times(1).WillOnce(::testing::Return("Ljava/lang/Object;"));
+  MockJBCClass2FEHelper klassHelper(allocator, *klass);
+  EXPECT_CALL(klassHelper, IsStaticFieldProguard()).Times(1).WillOnce(::testing::Return(true));
+  FEOptions::GetInstance().SetModeJavaStaticFieldName(FEOptions::kSmart);
+  JBCClassField2FEHelper fieldHelper(allocator, *field);
+  ASSERT_EQ(fieldHelper.ProcessDeclWithContainer(allocator, klassHelper), true);
+  // check field name
+  std::string fieldName = GlobalTables::GetStrTable().GetStringFromStrIdx(fieldHelper.mirFieldPair.first);
+  EXPECT_EQ(fieldName, "LTestPack_2FTestClass_3B_7Cfield__static_7CLjava_2Flang_2FObject_3B");
+  // check field type
+  MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(fieldHelper.mirFieldPair.second.first);
+  EXPECT_EQ(type->GetKind(), kTypePointer);
+  EXPECT_EQ(type->GetCompactMplTypeName(), "Ljava_2Flang_2FObject_3B");
+  // check field attr
+  EXPECT_EQ(fieldHelper.mirFieldPair.second.second.GetAttr(FLDATTR_private), true);
+}
+}  // namespace maple
diff --git a/src/mplfe/test/jbc_class_const_test.cpp b/src/mplfe/test/jbc_class_const_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..29ad33322bce17874556b2935849dc7d3ef37672
--- /dev/null
+++ b/src/mplfe/test/jbc_class_const_test.cpp
@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v1 for more details.
+ */
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+#include "jbc_class_const.h"
+
+namespace maple {
+namespace jbc {
+TEST(JBCClassConst, GetTagName) {
+  EXPECT_EQ(JBCConstTagName::GetTagName(kConstUTF8), "ConstUTF8");
+}
+}  // namespace jbc
+}  // namespace maple
\ No newline at end of file
diff --git a/src/mplfe/test/jbc_class_test.cpp b/src/mplfe/test/jbc_class_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..c23d5421910a787deff8c430d6a96a28324abda1
--- /dev/null
+++ b/src/mplfe/test/jbc_class_test.cpp
@@ -0,0 +1,119 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v1 for more details.
+ */
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+#include "base64.h"
+#include "jbc_class.h"
+
+namespace maple {
+namespace jbc {
+class JBCClassTest : public testing::Test {
+ public:
+  JBCClassTest()
+      : allocator(mp),
+        fileJBC0001(nullptr),
+        ioJBC0001(nullptr) {
+    LoadFileJBC0001();
+  }
+
+  ~JBCClassTest() = default;
+
+  void LoadFileJBC0001() {
+    std::string base64Str =
+        "yv66vgAAADQAKQoADQAiAxI0VngJAAwAIwRBgAAACQAMACQFAAAAEjRWeJAJ"
+        "AAwAJQbAMAAAAAAAAAkADAAmBwAnBwAoAQACdjEBAAFJAQACdjIBAAFKAQAC"
+        "djMBAAFGAQACdjQBAAFEAQAGPGluaXQ+AQADKClWAQAEQ29kZQEAD0xpbmVO"
+        "dW1iZXJUYWJsZQEAEkxvY2FsVmFyaWFibGVUYWJsZQEABHRoaXMBAAZMVGVz"
+        "dDsBAAVmdW5jMQEABWZ1bmMyAQAIPGNsaW5pdD4BAApTb3VyY2VGaWxlAQAJ"
+        "VGVzdC5qYXZhDAAWABcMAA4ADwwAEgATDAAQABEMABQAFQEABFRlc3QBABBq"
+        "YXZhL2xhbmcvT2JqZWN0ACEADAANAAAABAABAA4ADwAAAAkAEAARAAAAAQAS"
+        "ABMAAAAJABQAFQAAAAQAAQAWABcAAQAYAAAAQwACAAEAAAARKrcAASoSArUA"
+        "AyoSBLUABbEAAAACABkAAAAOAAMAAAABAAQAAgAKAAQAGgAAAAwAAQAAABEA"
+        "GwAcAAAAAQAdABcAAQAYAAAAKwAAAAEAAAABsQAAAAIAGQAAAAYAAQAAAAgA"
+        "GgAAAAwAAQAAAAEAGwAcAAAACQAeABcAAQAYAAAAGQAAAAAAAAABsQAAAAEA"
+        "GQAAAAYAAQAAAAsACAAfABcAAQAYAAAAKQACAAAAAAANFAAGswAIFAAJswAL"
+        "sQAAAAEAGQAAAAoAAgAAAAMABgAFAAEAIAAAAAIAIQ==";
+    size_t length = 0;
+    uint8 *ptr = Base64::Decode(base64Str, length);
+    fileJBC0001 = BasicIOMapFile::GenFileInMemory("JBC0001", ptr, length);
+    ioJBC0001 = mp->New<BasicIORead>(*fileJBC0001, true);
+  }
+
+  inline MapleAllocator &GetAllocator() {
+    return allocator;
+  }
+
+ protected:
+  static MemPool *mp;
+  MapleAllocator allocator;
+  std::unique_ptr<BasicIOMapFile> fileJBC0001;
+  BasicIORead *ioJBC0001;
+
+  static void SetUpTestCase() {
+    mp = memPoolCtrler.NewMemPool("MemPool for JBCClassTest");
+  }
+
+  static void TearDownTestCase() {
+    memPoolCtrler.DeleteMemPool(mp);
+    mp = nullptr;
+  }
+};
+MemPool *JBCClassTest::mp = nullptr;
+
+TEST_F(JBCClassTest, ParseFileJBC0001) {
+  JBCClass klass(allocator);
+  bool success = klass.ParseFile(*ioJBC0001);
+  EXPECT_EQ(success, true);
+  // ConstPoolCount test
+  uint16 constSize = klass.GetConstPoolCount();
+  EXPECT_EQ(constSize, 41);
+  // GetConstByIdx test
+  const JBCConst *const0 = klass.GetConstPool().GetConstByIdx(0);
+  EXPECT_EQ(const0, nullptr);
+  const JBCConst *const9 = klass.GetConstPool().GetConstByIdx(9);
+  EXPECT_NE(const9, nullptr);
+  const JBCConst *const42 = klass.GetConstPool().GetConstByIdx(42);
+  EXPECT_EQ(const42, nullptr);
+  // GetConstByIdxWithTag test
+  const JBCConst *const3 = klass.GetConstPool().GetConstByIdxWithTag(3, kConstFieldRef);
+  EXPECT_NE(const3, nullptr);
+  const JBCConst *const11 = klass.GetConstPool().GetConstByIdxWithTag(11, kConstUTF8);
+  EXPECT_EQ(const11, nullptr);
+  // GetConstValueByIdx test
+  const JBCConst *const4 = klass.GetConstPool().GetConstValueByIdx(4);
+  EXPECT_NE(const4, nullptr);
+  const JBCConst *const6 = klass.GetConstPool().GetConstValueByIdx(6);
+  EXPECT_NE(const6, nullptr);
+  const JBCConst *const8 = klass.GetConstPool().GetConstValueByIdx(8);
+  EXPECT_EQ(const8, nullptr);
+  // GetConstValue4ByteByIdx test
+  const4 = klass.GetConstPool().GetConstValue4ByteByIdx(4);
+  EXPECT_NE(const4, nullptr);
+  const6 = klass.GetConstPool().GetConstValue4ByteByIdx(6);
+  EXPECT_EQ(const6, nullptr);
+  // GetConstValue8ByteByIdx test
+  const4 = klass.GetConstPool().GetConstValue8ByteByIdx(4);
+  EXPECT_EQ(const4, nullptr);
+  const6 = klass.GetConstPool().GetConstValue8ByteByIdx(6);
+  EXPECT_NE(const6, nullptr);
+  // Field Count
+  EXPECT_EQ(klass.GetFieldCount(), 4);
+  // Method Count
+  EXPECT_EQ(klass.GetMethodCount(), 4);
+  // Attr Count
+  EXPECT_EQ(klass.GetAttrCount(), 1);
+}
+}  // namespace jbc
+}  // namespace maple
\ No newline at end of file
diff --git a/src/mplfe/test/jbc_function_test.cpp b/src/mplfe/test/jbc_function_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..2dc5888e1f02471922c906c643fe1b96c9067c8a
--- /dev/null
+++ b/src/mplfe/test/jbc_function_test.cpp
@@ -0,0 +1,166 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v1 for more details.
+ */
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+#include "jbc_function.h"
+#include "redirect_buffer.h"
+#include "mplfe_ut_environment.h"
+
+namespace maple {
+class JBCFunctionTest : public testing::Test, public RedirectBuffer {
+ public:
+  static MemPool *mp;
+  MapleAllocator allocator;
+  jbc::JBCClass jbcClass;
+  jbc::JBCClassMethod jbcMethod;
+  JBCClassMethod2FEHelper jbcMethodHelper;
+  MIRFunction mirFunction;
+  JBCFunction jbcFunction;
+  JBCFunctionTest()
+      : allocator(mp),
+        jbcClass(allocator),
+        jbcMethod(allocator, jbcClass),
+        jbcMethodHelper(allocator, jbcMethod),
+        mirFunction(&MPLFEUTEnvironment::GetMIRModule(), StIdx(0, 0)),
+        jbcFunction(jbcMethodHelper, mirFunction, std::make_unique<FEFunctionPhaseResult>(true)) {}
+  ~JBCFunctionTest() = default;
+
+  static void SetUpTestCase() {
+    mp = memPoolCtrler.NewMemPool("MemPool for JBCFunctionTest");
+  }
+
+  static void TearDownTestCase() {
+    memPoolCtrler.DeleteMemPool(mp);
+    mp = nullptr;
+  }
+};
+MemPool *JBCFunctionTest::mp = nullptr;
+
+TEST_F(JBCFunctionTest, BuildTryInfo_Case1) {
+  std::map<std::pair<uint32, uint32>, std::vector<uint32>> rawInfo;
+  /* Case1
+   * S(0)--E(10)--C(20)
+   */
+  rawInfo[std::make_pair(0, 10)] = std::vector<uint32>({ 20 });
+  std::map<uint32, uint32> outMapStartEnd;
+  std::map<uint32, std::vector<uint32>> outMapStartCatch;
+  jbcFunction.BuildTryInfo(rawInfo, outMapStartEnd, outMapStartCatch);
+  EXPECT_EQ(outMapStartEnd[0], 10);
+  ASSERT_EQ(outMapStartCatch[0].size(), 1);
+  EXPECT_EQ(outMapStartCatch[0][0], 20);
+}
+
+TEST_F(JBCFunctionTest, BuildTryInfo_Case2) {
+  std::map<std::pair<uint32, uint32>, std::vector<uint32>> rawInfo;
+  /* Case2
+   * S(0)--E(10)--C(10)
+   */
+  rawInfo[std::make_pair(0, 10)] = std::vector<uint32>({ 10 });
+  std::map<uint32, uint32> outMapStartEnd;
+  std::map<uint32, std::vector<uint32>> outMapStartCatch;
+  jbcFunction.BuildTryInfo(rawInfo, outMapStartEnd, outMapStartCatch);
+  EXPECT_EQ(outMapStartEnd[0], 10);
+  ASSERT_EQ(outMapStartCatch[0].size(), 1);
+  EXPECT_EQ(outMapStartCatch[0][0], 10);
+}
+
+TEST_F(JBCFunctionTest, BuildTryInfo_Case3) {
+  std::map<std::pair<uint32, uint32>, std::vector<uint32>> rawInfo;
+  /* Case3
+   * S(0)--E(10)--C(5)
+   */
+  rawInfo[std::make_pair(0, 10)] = std::vector<uint32>({ 5 });
+  std::map<uint32, uint32> outMapStartEnd;
+  std::map<uint32, std::vector<uint32>> outMapStartCatch;
+  jbcFunction.BuildTryInfo(rawInfo, outMapStartEnd, outMapStartCatch);
+  EXPECT_EQ(outMapStartEnd[0], 5);
+  EXPECT_EQ(outMapStartEnd[5], 10);
+  ASSERT_EQ(outMapStartCatch[0].size(), 1);
+  ASSERT_EQ(outMapStartCatch[5].size(), 1);
+  EXPECT_EQ(outMapStartCatch[0][0], 5);
+  EXPECT_EQ(outMapStartCatch[5][0], 5);
+}
+
+TEST_F(JBCFunctionTest, BuildTryInfo_Case4) {
+  std::map<std::pair<uint32, uint32>, std::vector<uint32>> rawInfo;
+  /* Case4
+   * S1/S2(0)--E1(10)--E2(20)--C1(25)--C2(30)
+   */
+  rawInfo[std::make_pair(0, 10)] = std::vector<uint32>({ 25 });
+  rawInfo[std::make_pair(0, 20)] = std::vector<uint32>({ 30 });
+  std::map<uint32, uint32> outMapStartEnd;
+  std::map<uint32, std::vector<uint32>> outMapStartCatch;
+  jbcFunction.BuildTryInfo(rawInfo, outMapStartEnd, outMapStartCatch);
+  EXPECT_EQ(outMapStartEnd[0], 10);
+  EXPECT_EQ(outMapStartEnd[10], 20);
+  ASSERT_EQ(outMapStartCatch[0].size(), 2);
+  ASSERT_EQ(outMapStartCatch[10].size(), 1);
+  EXPECT_EQ(outMapStartCatch[0][0], 25);
+  EXPECT_EQ(outMapStartCatch[0][1], 30);
+  EXPECT_EQ(outMapStartCatch[10][0], 30);
+}
+
+TEST_F(JBCFunctionTest, BuildTryInfo_Case5) {
+  std::map<std::pair<uint32, uint32>, std::vector<uint32>> rawInfo;
+  /* Case5
+   * S(0)--E(10)--C_1(20)--C_2(30)
+   */
+  rawInfo[std::make_pair(0, 10)] = std::vector<uint32>({ 20, 30 });
+  std::map<uint32, uint32> outMapStartEnd;
+  std::map<uint32, std::vector<uint32>> outMapStartCatch;
+  jbcFunction.BuildTryInfo(rawInfo, outMapStartEnd, outMapStartCatch);
+  EXPECT_EQ(outMapStartEnd[0], 10);
+  ASSERT_EQ(outMapStartCatch[0].size(), 2);
+  EXPECT_EQ(outMapStartCatch[0][0], 20);
+  EXPECT_EQ(outMapStartCatch[0][1], 30);
+}
+
+TEST_F(JBCFunctionTest, BuildTryInfo_Case6) {
+  std::map<std::pair<uint32, uint32>, std::vector<uint32>> rawInfo;
+  /* Case6
+   * S(0)--C_1(5)--E(10)--C_2(20)
+   */
+  rawInfo[std::make_pair(0, 10)] = std::vector<uint32>({ 5, 20 });
+  std::map<uint32, uint32> outMapStartEnd;
+  std::map<uint32, std::vector<uint32>> outMapStartCatch;
+  jbcFunction.BuildTryInfo(rawInfo, outMapStartEnd, outMapStartCatch);
+  EXPECT_EQ(outMapStartEnd[0], 5);
+  EXPECT_EQ(outMapStartEnd[5], 10);
+  ASSERT_EQ(outMapStartCatch[0].size(), 2);
+  EXPECT_EQ(outMapStartCatch[0][0], 5);
+  EXPECT_EQ(outMapStartCatch[0][1], 20);
+  ASSERT_EQ(outMapStartCatch[5].size(), 2);
+  EXPECT_EQ(outMapStartCatch[5][0], 5);
+  EXPECT_EQ(outMapStartCatch[5][1], 20);
+}
+
+TEST_F(JBCFunctionTest, BuildTryInfo_Case7) {
+  std::map<std::pair<uint32, uint32>, std::vector<uint32>> rawInfo;
+  /* Case7
+   * S1(0)-E1(10)-C1(20)-S2(30)-E2(40)-C2(50)
+   */
+  rawInfo[std::make_pair(0, 10)] = std::vector<uint32>({ 20 });
+  rawInfo[std::make_pair(30, 40)] = std::vector<uint32>({ 50 });
+  std::map<uint32, uint32> outMapStartEnd;
+  std::map<uint32, std::vector<uint32>> outMapStartCatch;
+  jbcFunction.BuildTryInfo(rawInfo, outMapStartEnd, outMapStartCatch);
+  EXPECT_EQ(outMapStartEnd[0], 10);
+  EXPECT_EQ(outMapStartEnd[30], 40);
+  ASSERT_EQ(outMapStartCatch[0].size(), 1);
+  EXPECT_EQ(outMapStartCatch[0][0], 20);
+  ASSERT_EQ(outMapStartCatch[30].size(), 1);
+  EXPECT_EQ(outMapStartCatch[30][0], 50);
+}
+}  // namespace maple
\ No newline at end of file
diff --git a/src/mplfe/test/jbc_input/JBC0001/Test.class b/src/mplfe/test/jbc_input/JBC0001/Test.class
new file mode 100644
index 0000000000000000000000000000000000000000..cf22eb34e438f9f941d7d250d399800556b849d5
Binary files /dev/null and b/src/mplfe/test/jbc_input/JBC0001/Test.class differ
diff --git a/src/mplfe/test/jbc_input/JBC0001/Test.java b/src/mplfe/test/jbc_input/JBC0001/Test.java
new file mode 100644
index 0000000000000000000000000000000000000000..d441a9debb157f5d81b473ab6e823419f5269b17
--- /dev/null
+++ b/src/mplfe/test/jbc_input/JBC0001/Test.java
@@ -0,0 +1,12 @@
+public class Test {
+    public int v1 = 0x12345678;
+    public static long v2 = 0x1234567890l;
+    public float v3 = 16.0f;
+    public static double v4 = -16.0;
+    
+    public void func1() {
+    }
+
+    public static void func2() {
+    }
+}
diff --git a/src/mplfe/test/jbc_opcode_helper_test.cpp b/src/mplfe/test/jbc_opcode_helper_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..3096bdc11b637d6b892aefc0a5996794a75ae83b
--- /dev/null
+++ b/src/mplfe/test/jbc_opcode_helper_test.cpp
@@ -0,0 +1,179 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v1 for more details.
+ */
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+#include "fe_configs.h"
+#include "base64.h"
+#include "mempool.h"
+#include "mempool_allocator.h"
+#include "jbc_class.h"
+#include "jbc_opcode.h"
+#include "jbc_opcode_helper.h"
+#include "redirect_buffer.h"
+
+namespace maple {
+class JBCOpcodeHelperTest : public testing::Test, public RedirectBuffer {
+ public:
+  JBCOpcodeHelperTest()
+      : allocator(mp),
+        klass(allocator),
+        method(allocator, klass),
+        helper(method) {}
+  ~JBCOpcodeHelperTest() = default;
+
+  static void SetUpTestCase() {
+    mp = memPoolCtrler.NewMemPool("MemPool for JBCOpcodeHelperTest");
+  }
+
+  static void TearDownTestCase() {
+    memPoolCtrler.DeleteMemPool(mp);
+    mp = nullptr;
+  }
+
+ LLT_PRIVATE:
+  static MemPool *mp;
+  MapleAllocator allocator;
+  jbc::JBCClass klass;
+  jbc::JBCClassMethod method;
+  JBCOpcodeHelper helper;
+};  // class JBCOpcodeHelperTest
+MemPool *JBCOpcodeHelperTest::mp = nullptr;
+
+TEST_F(JBCOpcodeHelperTest, GetBaseTypeNamesForOPDefault) {
+  jbc::JBCOpGoto *op = mp->New<jbc::JBCOpGoto>(allocator, jbc::kOpGoto, jbc::kOpKindGoto, false);
+  bool success = false;
+  std::vector<std::string> ans = helper.GetBaseTypeNamesForOP(*op, success);
+  EXPECT_EQ(success, true);
+  EXPECT_EQ(ans.size(), 0);
+}
+
+TEST_F(JBCOpcodeHelperTest, GetBaseTypeNamesForOPConst_Class) {
+  uint16 idxConstClass;
+  (void)klass.constPool.NewConstClass(idxConstClass, "Ljava/lang/Object;");
+  jbc::JBCOpConst *op = mp->New<jbc::JBCOpConst>(allocator, jbc::kOpLdc, jbc::kOpKindConst, false);
+  op->SetIndex(idxConstClass);
+  bool success = false;
+  std::vector<std::string> ans = helper.GetBaseTypeNamesForOP(*op, success);
+  EXPECT_EQ(success, true);
+  ASSERT_EQ(ans.size(), 1);
+  EXPECT_EQ(ans[0], "Ljava/lang/Object;");
+  op->SetIndex(0xFFFF);
+  ans = helper.GetBaseTypeNamesForOP(*op, success);
+  EXPECT_EQ(success, false);
+  EXPECT_EQ(ans.size(), 0);
+}
+
+TEST_F(JBCOpcodeHelperTest, GetBaseTypeNamesForOPFieldOpr) {
+  uint16 idxConstRef;
+  (void)klass.constPool.NewConstRef(idxConstRef, jbc::kConstFieldRef, "LTest;", "field", "Ljava/lang/String;");
+  jbc::JBCOpFieldOpr *op = mp->New<jbc::JBCOpFieldOpr>(allocator, jbc::kOpGetField, jbc::kOpKindFieldOpr, false);
+  op->SetFieldIdx(idxConstRef);
+  bool success = false;
+  std::vector<std::string> ans = helper.GetBaseTypeNamesForOP(*op, success);
+  EXPECT_EQ(success, true);
+  ASSERT_EQ(ans.size(), 1);
+  EXPECT_EQ(ans[0], "Ljava/lang/String;");
+  op->SetFieldIdx(0xFFFF);
+  ans = helper.GetBaseTypeNamesForOP(*op, success);
+  EXPECT_EQ(success, false);
+  EXPECT_EQ(ans.size(), 0);
+}
+
+TEST_F(JBCOpcodeHelperTest, GetBaseTypeNamesForOPInvoke) {
+  uint16 idxConstRef;
+  (void)klass.constPool.NewConstRef(idxConstRef, jbc::kConstMethodRef, "LTest;", "method",
+                                         "(Ljava/lang/String;IJ)Ljava/lang/Object;");
+  jbc::JBCOpInvoke *op = mp->New<jbc::JBCOpInvoke>(allocator, jbc::kOpInvokeVirtual, jbc::kOpKindInvoke, false);
+  op->SetMethodIdx(idxConstRef);
+  bool success = false;
+  std::vector<std::string> ans = helper.GetBaseTypeNamesForOP(*op, success);
+  EXPECT_EQ(success, true);
+  ASSERT_EQ(ans.size(), 4);
+  EXPECT_EQ(ans[0], "Ljava/lang/Object;");
+  EXPECT_EQ(ans[1], "Ljava/lang/String;");
+  EXPECT_EQ(ans[2], "I");
+  EXPECT_EQ(ans[3], "J");
+  op->SetMethodIdx(0xFFFF);
+  ans = helper.GetBaseTypeNamesForOP(*op, success);
+  EXPECT_EQ(success, false);
+  EXPECT_EQ(ans.size(), 0);
+}
+
+TEST_F(JBCOpcodeHelperTest, GetBaseTypeNamesForOPNew) {
+  uint16 idxConstClass;
+  (void)klass.constPool.NewConstClass(idxConstClass, "Ljava/lang/Integer;");
+  jbc::JBCOpNew *op = mp->New<jbc::JBCOpNew>(allocator, jbc::kOpNew, jbc::kOpKindNew, false);
+  op->SetRefTypeIdx(idxConstClass);
+  bool success = false;
+  std::vector<std::string> ans = helper.GetBaseTypeNamesForOP(*op, success);
+  EXPECT_EQ(success, true);
+  ASSERT_EQ(ans.size(), 1);
+  EXPECT_EQ(ans[0], "Ljava/lang/Integer;");
+  op->SetRefTypeIdx(0xFFFF);
+  ans = helper.GetBaseTypeNamesForOP(*op, success);
+  EXPECT_EQ(success, false);
+  EXPECT_EQ(ans.size(), 0);
+}
+
+TEST_F(JBCOpcodeHelperTest, GetBaseTypeNamesForOPNew_Array) {
+  uint16 idxConstClass;
+  (void)klass.constPool.NewConstClass(idxConstClass, "[Ljava/lang/Float;");
+  jbc::JBCOpNew *op = mp->New<jbc::JBCOpNew>(allocator, jbc::kOpANewArray, jbc::kOpKindNew, false);
+  op->SetRefTypeIdx(idxConstClass);
+  bool success = false;
+  std::vector<std::string> ans = helper.GetBaseTypeNamesForOP(*op, success);
+  EXPECT_EQ(success, true);
+  ASSERT_EQ(ans.size(), 1);
+  EXPECT_EQ(ans[0], "Ljava/lang/Float;");
+  op->SetRefTypeIdx(0xFFFF);
+  ans = helper.GetBaseTypeNamesForOP(*op, success);
+  EXPECT_EQ(success, false);
+  EXPECT_EQ(ans.size(), 0);
+}
+
+TEST_F(JBCOpcodeHelperTest, GetBaseTypeNamesForOPMultiANewArray) {
+  uint16 idxConstClass;
+  (void)klass.constPool.NewConstClass(idxConstClass, "[Ljava/lang/Double;");
+  jbc::JBCOpMultiANewArray *op = mp->New<jbc::JBCOpMultiANewArray>(allocator, jbc::kOpMultiANewArray,
+                                                                   jbc::kOpKindMultiANewArray, false);
+  op->SetRefTypeIdx(idxConstClass);
+  bool success = false;
+  std::vector<std::string> ans = helper.GetBaseTypeNamesForOP(*op, success);
+  EXPECT_EQ(success, true);
+  ASSERT_EQ(ans.size(), 1);
+  EXPECT_EQ(ans[0], "Ljava/lang/Double;");
+  op->SetRefTypeIdx(0xFFFF);
+  ans = helper.GetBaseTypeNamesForOP(*op, success);
+  EXPECT_EQ(success, false);
+  EXPECT_EQ(ans.size(), 0);
+}
+
+TEST_F(JBCOpcodeHelperTest, GetBaseTypeNamesForOPTypeCheck) {
+  uint16 idxConstClass;
+  (void)klass.constPool.NewConstClass(idxConstClass, "Ljava/lang/Object;");
+  jbc::JBCOpTypeCheck *op = mp->New<jbc::JBCOpTypeCheck>(allocator, jbc::kOpCheckCast,
+                                                         jbc::kOpKindTypeCheck, false);
+  op->SetTypeIdx(idxConstClass);
+  bool success = false;
+  std::vector<std::string> ans = helper.GetBaseTypeNamesForOP(*op, success);
+  EXPECT_EQ(success, true);
+  ASSERT_EQ(ans.size(), 1);
+  EXPECT_EQ(ans[0], "Ljava/lang/Object;");
+  op->SetTypeIdx(0xFFFF);
+  ans = helper.GetBaseTypeNamesForOP(*op, success);
+  EXPECT_EQ(success, false);
+  EXPECT_EQ(ans.size(), 0);
+}
+}  // namespace maple
\ No newline at end of file
diff --git a/src/mplfe/test/jbc_stack2fe_helper_test.cpp b/src/mplfe/test/jbc_stack2fe_helper_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..da50ac9d649e3c342655c12c510e94033a926455
--- /dev/null
+++ b/src/mplfe/test/jbc_stack2fe_helper_test.cpp
@@ -0,0 +1,615 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v1 for more details.
+ */
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+#include <memory>
+#include "jbc_stack_helper.h"
+#include "jbc_stack2fe_helper.h"
+#include "feir_test_base.h"
+#include "mplfe_ut_regx.h"
+
+namespace maple {
+class JBCStack2FEHelperTest : public FEIRTestBase {
+ public:
+  JBCStackHelper stackHelper;
+  JBCStack2FEHelper helper;
+  JBCStack2FEHelperTest() = default;
+  ~JBCStack2FEHelperTest() = default;
+};  // class JBCStack2FEHelperTest
+
+TEST_F(JBCStack2FEHelperTest, GetRegNumForSlot) {
+  helper.SetNStacks(8);
+  helper.SetNSwaps(2);
+  helper.SetNLocals(4);
+  helper.SetNArgs(4);
+  // 0~7: stack
+  // 8~9: swap
+  // 10~13: local
+  // 14~17: arg
+  EXPECT_EQ(helper.GetRegNumForSlot(0), 14);
+  EXPECT_EQ(helper.GetRegNumForSlot(2), 16);
+  EXPECT_EQ(helper.GetRegNumForSlot(4), 10);
+  EXPECT_EQ(helper.GetRegNumForSlot(6), 12);
+}
+
+TEST_F(JBCStack2FEHelperTest, PushItem_PopItem) {
+  helper.SetNStacks(3);
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(0), PTY_i32), true);
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(1), PTY_i64), true);
+  EXPECT_EQ(helper.DumpStackInJavaFormat(), "IJJ");
+  EXPECT_EQ(helper.DumpStackInInternalFormat(), "NWD");
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(3), PTY_f32), false);
+  UniqueFEIRVar var = helper.PopItem(PTY_i32);
+  EXPECT_EQ(var, nullptr);
+  var = helper.PopItem(PTY_i64);
+  EXPECT_EQ(var->GetNameRaw(), "Reg1");
+  EXPECT_EQ(helper.DumpStackInJavaFormat(), "I");
+  EXPECT_EQ(helper.DumpStackInInternalFormat(), "N");
+  var = helper.PopItem(PTY_i64);
+  EXPECT_EQ(var, nullptr);
+  var = helper.PopItem(PTY_i32);
+  EXPECT_EQ(var->GetNameRaw(), "Reg0");
+  EXPECT_EQ(helper.DumpStackInJavaFormat(), "");
+  EXPECT_EQ(helper.DumpStackInInternalFormat(), "");
+  var = helper.PopItem(PTY_i32);
+  EXPECT_EQ(var, nullptr);
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(0), PTY_i32), true);
+  var = helper.PopItem(PTY_f32);
+  EXPECT_EQ(var, nullptr);
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(1), PTY_i64), true);
+  var = helper.PopItem(PTY_f64);
+  EXPECT_EQ(var, nullptr);
+}
+
+TEST_F(JBCStack2FEHelperTest, GetRegNumForStack) {
+  helper.SetNStacks(6);
+  helper.ClearStack();
+  EXPECT_EQ(helper.GetRegNumForStack(), 0);
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(0), PTY_i64), true);
+  EXPECT_EQ(helper.GetRegNumForStack(), 2);
+  helper.ClearStack();
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(1), PTY_i64), true);
+  EXPECT_EQ(helper.GetRegNumForStack(), 0);
+}
+
+TEST_F(JBCStack2FEHelperTest, Swap) {
+  helper.SetNStacks(6);
+  helper.ClearStack();
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(0), PTY_i32), true);
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(1), PTY_f32), true);
+  EXPECT_EQ(helper.DumpStackInJavaFormat(), "IF");
+  EXPECT_EQ(helper.DumpStackInInternalFormat(), "NN");
+  EXPECT_EQ(helper.Swap(), true);
+  EXPECT_EQ(helper.DumpStackInJavaFormat(), "FI");
+  EXPECT_EQ(helper.DumpStackInInternalFormat(), "NN");
+  UniqueFEIRVar var = helper.PopItem(PTY_i32);
+  EXPECT_EQ(var->GetNameRaw(), "Reg0");
+  var = helper.PopItem(PTY_f32);
+  EXPECT_EQ(var->GetNameRaw(), "Reg1");
+  EXPECT_EQ(helper.DumpStackInJavaFormat(), "");
+  EXPECT_EQ(helper.DumpStackInInternalFormat(), "");
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(0), PTY_i64), true);
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(2), PTY_f64), true);
+  EXPECT_EQ(helper.DumpStackInJavaFormat(), "JJDD");
+  EXPECT_EQ(helper.DumpStackInInternalFormat(), "WDWD");
+  EXPECT_EQ(helper.Swap(), false);
+  helper.ClearStack();
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(0), PTY_i32), true);
+  EXPECT_EQ(helper.Swap(), false);
+}
+
+TEST_F(JBCStack2FEHelperTest, Pop) {
+  helper.SetNStacks(6);
+  helper.ClearStack();
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(0), PTY_i32), true);
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(1), PTY_f32), true);
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(2), PTY_ref), true);
+  EXPECT_EQ(helper.DumpStackInJavaFormat(), "IFR");
+  EXPECT_EQ(helper.DumpStackInInternalFormat(), "NNN");
+  EXPECT_EQ(helper.Pop(jbc::kOpPop), true);
+  EXPECT_EQ(helper.DumpStackInJavaFormat(), "IF");
+  EXPECT_EQ(helper.DumpStackInInternalFormat(), "NN");
+  EXPECT_EQ(helper.Pop(jbc::kOpPop2), true);
+  EXPECT_EQ(helper.DumpStackInJavaFormat(), "");
+  EXPECT_EQ(helper.DumpStackInInternalFormat(), "");
+  EXPECT_EQ(helper.Pop(jbc::kOpPop), false);
+  EXPECT_EQ(helper.Pop(jbc::kOpPop2), false);
+  EXPECT_EQ(helper.Pop(jbc::kOpDup), false);
+}
+
+TEST_F(JBCStack2FEHelperTest, Pop2) {
+  helper.SetNStacks(6);
+  helper.ClearStack();
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(0), PTY_i64), true);
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(2), PTY_f64), true);
+  EXPECT_EQ(helper.DumpStackInJavaFormat(), "JJDD");
+  EXPECT_EQ(helper.DumpStackInInternalFormat(), "WDWD");
+  EXPECT_EQ(helper.Pop(jbc::kOpPop), false);
+  EXPECT_EQ(helper.Pop(jbc::kOpPop2), true);
+  EXPECT_EQ(helper.DumpStackInJavaFormat(), "JJ");
+  EXPECT_EQ(helper.DumpStackInInternalFormat(), "WD");
+  EXPECT_EQ(helper.Pop(jbc::kOpPop2), true);
+  EXPECT_EQ(helper.DumpStackInJavaFormat(), "");
+  EXPECT_EQ(helper.DumpStackInInternalFormat(), "");
+  EXPECT_EQ(helper.Pop(jbc::kOpPop2), false);
+  EXPECT_EQ(helper.Pop(jbc::kOpDup), false);
+}
+
+TEST_F(JBCStack2FEHelperTest, Dup_Correct) {
+  helper.SetNStacks(6);
+  helper.ClearStack();
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(0), PTY_i32), true);
+  EXPECT_EQ(helper.DumpStackInJavaFormat(), "I");
+  EXPECT_EQ(helper.DumpStackInInternalFormat(), "N");
+  EXPECT_EQ(helper.Dup(jbc::kOpDup), true);
+  EXPECT_EQ(helper.DumpStackInJavaFormat(), "II");
+  EXPECT_EQ(helper.DumpStackInInternalFormat(), "NN");
+  PrimType pty;
+  UniqueFEIRVar var1 = helper.PopItem(false, pty);
+  EXPECT_EQ(pty, PTY_i32);
+  EXPECT_EQ(var1->GetNameRaw(), "Reg0");
+  UniqueFEIRVar var2 = helper.PopItem(false, pty);
+  EXPECT_EQ(pty, PTY_i32);
+  EXPECT_EQ(var2->GetNameRaw(), "Reg0");
+}
+
+TEST_F(JBCStack2FEHelperTest, Dup_Error_Empty) {
+  helper.SetNStacks(6);
+  helper.ClearStack();
+  EXPECT_EQ(helper.Dup(jbc::kOpDup), false);
+}
+
+TEST_F(JBCStack2FEHelperTest, Dup_Error_WrongType) {
+  helper.SetNStacks(6);
+  helper.ClearStack();
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(0), PTY_i64), true);
+  EXPECT_EQ(helper.DumpStackInJavaFormat(), "JJ");
+  EXPECT_EQ(helper.DumpStackInInternalFormat(), "WD");
+  EXPECT_EQ(helper.Dup(jbc::kOpDup), false);
+}
+
+TEST_F(JBCStack2FEHelperTest, DupX1_Correct) {
+  helper.SetNStacks(6);
+  helper.ClearStack();
+  // before: Reg0_ref, Reg1_i32, Reg2_f32, ->
+  // after:  Reg0_ref, Reg2_f32, Reg1_i32, Reg2_f32, ->
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(0), PTY_ref), true);
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(1), PTY_i32), true);
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(2), PTY_f32), true);
+  EXPECT_EQ(helper.DumpStackInJavaFormat(), "RIF");
+  EXPECT_EQ(helper.DumpStackInInternalFormat(), "NNN");
+  EXPECT_EQ(helper.Dup(jbc::kOpDupX1), true);
+  EXPECT_EQ(helper.DumpStackInJavaFormat(), "RFIF");
+  EXPECT_EQ(helper.DumpStackInInternalFormat(), "NNNN");
+  PrimType pty;
+  UniqueFEIRVar var = helper.PopItem(false, pty);
+  EXPECT_EQ(pty, PTY_f32);
+  EXPECT_EQ(var->GetNameRaw(), "Reg2");
+  UniqueFEIRVar var2 = helper.PopItem(false, pty);
+  EXPECT_EQ(pty, PTY_i32);
+  EXPECT_EQ(var2->GetNameRaw(), "Reg1");
+  UniqueFEIRVar var3 = helper.PopItem(false, pty);
+  EXPECT_EQ(pty, PTY_f32);
+  EXPECT_EQ(var3->GetNameRaw(), "Reg2");
+}
+
+TEST_F(JBCStack2FEHelperTest, DupX1_Error_NotEnough) {
+  helper.SetNStacks(6);
+  helper.ClearStack();
+  // before: ->
+  // after:  Error
+  EXPECT_EQ(helper.Dup(jbc::kOpDupX1), false);
+  // before: ->
+  // after:  Error
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(0), PTY_ref), true);
+  EXPECT_EQ(helper.Dup(jbc::kOpDupX1), false);
+}
+
+TEST_F(JBCStack2FEHelperTest, DupX1_Error_WrongType) {
+  helper.SetNStacks(6);
+  helper.ClearStack();
+  // before: Reg0_ref, Reg1_i64, ->
+  // after:  Error
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(0), PTY_ref), true);
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(1), PTY_i64), true);
+  EXPECT_EQ(helper.Dup(jbc::kOpDupX1), false);
+}
+
+TEST_F(JBCStack2FEHelperTest, DupX2_Correct_S1) {
+  helper.SetNStacks(6);
+  helper.ClearStack();
+  // before: Reg0_ref, Reg1_ref, Reg2_i32, Reg3_f32, ->
+  // after:  Reg0_ref, Reg3_f32, Reg1_ref, Reg2_i32, Reg3_f32, ->
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(0), PTY_ref), true);
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(1), PTY_ref), true);
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(2), PTY_i32), true);
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(3), PTY_f32), true);
+  EXPECT_EQ(helper.DumpStackInJavaFormat(), "RRIF");
+  EXPECT_EQ(helper.DumpStackInInternalFormat(), "NNNN");
+  EXPECT_EQ(helper.Dup(jbc::kOpDupX2), true);
+  EXPECT_EQ(helper.DumpStackInJavaFormat(), "RFRIF");
+  EXPECT_EQ(helper.DumpStackInInternalFormat(), "NNNNN");
+  PrimType pty;
+  UniqueFEIRVar var = helper.PopItem(false, pty);
+  EXPECT_EQ(pty, PTY_f32);
+  EXPECT_EQ(var->GetNameRaw(), "Reg3");
+  UniqueFEIRVar var2 = helper.PopItem(false, pty);
+  EXPECT_EQ(pty, PTY_i32);
+  EXPECT_EQ(var2->GetNameRaw(), "Reg2");
+  UniqueFEIRVar var3 = helper.PopItem(false, pty);
+  EXPECT_EQ(pty, PTY_ref);
+  EXPECT_EQ(var3->GetNameRaw(), "Reg1");
+  UniqueFEIRVar var4 = helper.PopItem(false, pty);
+  EXPECT_EQ(pty, PTY_f32);
+  EXPECT_EQ(var4->GetNameRaw(), "Reg3");
+}
+
+TEST_F(JBCStack2FEHelperTest, DupX2_Correct_S2) {
+  helper.SetNStacks(6);
+  helper.ClearStack();
+  // before: Reg0_ref, Reg1_i64, Reg3_i32, ->
+  // after:  Reg0_ref, Reg3_i32, Reg1_i64, Reg3_i32, ->
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(0), PTY_ref), true);
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(1), PTY_i64), true);
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(3), PTY_i32), true);
+  EXPECT_EQ(helper.DumpStackInJavaFormat(), "RJJI");
+  EXPECT_EQ(helper.DumpStackInInternalFormat(), "NWDN");
+  EXPECT_EQ(helper.Dup(jbc::kOpDupX2), true);
+  EXPECT_EQ(helper.DumpStackInJavaFormat(), "RIJJI");
+  EXPECT_EQ(helper.DumpStackInInternalFormat(), "NNWDN");
+  PrimType pty;
+  UniqueFEIRVar var1 = helper.PopItem(false, pty);
+  EXPECT_EQ(pty, PTY_i32);
+  EXPECT_EQ(var1->GetNameRaw(), "Reg3");
+  UniqueFEIRVar var2 = helper.PopItem(true, pty);
+  EXPECT_EQ(pty, PTY_i64);
+  EXPECT_EQ(var2->GetNameRaw(), "Reg1");
+  UniqueFEIRVar var3 = helper.PopItem(false, pty);
+  EXPECT_EQ(pty, PTY_i32);
+  EXPECT_EQ(var3->GetNameRaw(), "Reg3");
+}
+
+TEST_F(JBCStack2FEHelperTest, Dup2_Correct_S1) {
+  helper.SetNStacks(6);
+  helper.ClearStack();
+  // before: Reg0_ref, Reg1_i32, Reg2_f32, ->
+  // after:  Reg0_ref, Reg1_i32, Reg2_f32, Reg1_i32, Reg2_f32, ->
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(0), PTY_ref), true);
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(1), PTY_i32), true);
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(2), PTY_f32), true);
+  EXPECT_EQ(helper.DumpStackInJavaFormat(), "RIF");
+  EXPECT_EQ(helper.DumpStackInInternalFormat(), "NNN");
+  EXPECT_EQ(helper.Dup(jbc::kOpDup2), true);
+  EXPECT_EQ(helper.DumpStackInJavaFormat(), "RIFIF");
+  EXPECT_EQ(helper.DumpStackInInternalFormat(), "NNNNN");
+  PrimType pty;
+  UniqueFEIRVar var1 = helper.PopItem(false, pty);
+  EXPECT_EQ(pty, PTY_f32);
+  EXPECT_EQ(var1->GetNameRaw(), "Reg2");
+  UniqueFEIRVar var2 = helper.PopItem(false, pty);
+  EXPECT_EQ(pty, PTY_i32);
+  EXPECT_EQ(var2->GetNameRaw(), "Reg1");
+  UniqueFEIRVar var3 = helper.PopItem(false, pty);
+  EXPECT_EQ(pty, PTY_f32);
+  EXPECT_EQ(var3->GetNameRaw(), "Reg2");
+  UniqueFEIRVar var4 = helper.PopItem(false, pty);
+  EXPECT_EQ(pty, PTY_i32);
+  EXPECT_EQ(var4->GetNameRaw(), "Reg1");
+}
+
+TEST_F(JBCStack2FEHelperTest, Dup2_Correct_S2) {
+  helper.SetNStacks(6);
+  helper.ClearStack();
+  // before: Reg0_ref, Reg1_i64 ->
+  // after:  Reg0_ref, Reg1_i64, Reg1_i64 ->
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(0), PTY_ref), true);
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(1), PTY_i64), true);
+  EXPECT_EQ(helper.DumpStackInJavaFormat(), "RJJ");
+  EXPECT_EQ(helper.DumpStackInInternalFormat(), "NWD");
+  EXPECT_EQ(helper.Dup(jbc::kOpDup2), true);
+  EXPECT_EQ(helper.DumpStackInJavaFormat(), "RJJJJ");
+  EXPECT_EQ(helper.DumpStackInInternalFormat(), "NWDWD");
+  PrimType pty;
+  UniqueFEIRVar var1 = helper.PopItem(true, pty);
+  EXPECT_EQ(pty, PTY_i64);
+  EXPECT_EQ(var1->GetNameRaw(), "Reg1");
+  UniqueFEIRVar var2 = helper.PopItem(true, pty);
+  EXPECT_EQ(pty, PTY_i64);
+  EXPECT_EQ(var2->GetNameRaw(), "Reg1");
+}
+
+TEST_F(JBCStack2FEHelperTest, Dup2X1_Correct_S1) {
+  helper.SetNStacks(6);
+  helper.ClearStack();
+  // before: Reg0_ref, Reg1_i32, Reg2_f32, Reg3_ref ->
+  // after:  Reg0_ref, Reg2_f32, Reg3_ref, Reg1_i32, Reg2_f32, Reg3_ref ->
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(0), PTY_ref), true);
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(1), PTY_i32), true);
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(2), PTY_f32), true);
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(3), PTY_ref), true);
+  EXPECT_EQ(helper.DumpStackInJavaFormat(), "RIFR");
+  EXPECT_EQ(helper.DumpStackInInternalFormat(), "NNNN");
+  EXPECT_EQ(helper.Dup(jbc::kOpDup2X1), true);
+  EXPECT_EQ(helper.DumpStackInJavaFormat(), "RFRIFR");
+  EXPECT_EQ(helper.DumpStackInInternalFormat(), "NNNNNN");
+  PrimType pty;
+  UniqueFEIRVar var1 = helper.PopItemAuto(pty);
+  EXPECT_EQ(pty, PTY_ref);
+  EXPECT_EQ(var1->GetNameRaw(), "Reg3");
+  UniqueFEIRVar var2 = helper.PopItemAuto(pty);
+  EXPECT_EQ(pty, PTY_f32);
+  EXPECT_EQ(var2->GetNameRaw(), "Reg2");
+  UniqueFEIRVar var3 = helper.PopItemAuto(pty);
+  EXPECT_EQ(pty, PTY_i32);
+  EXPECT_EQ(var3->GetNameRaw(), "Reg1");
+  UniqueFEIRVar var4 = helper.PopItemAuto(pty);
+  EXPECT_EQ(pty, PTY_ref);
+  EXPECT_EQ(var4->GetNameRaw(), "Reg3");
+  UniqueFEIRVar var5 = helper.PopItemAuto(pty);
+  EXPECT_EQ(pty, PTY_f32);
+  EXPECT_EQ(var5->GetNameRaw(), "Reg2");
+}
+
+TEST_F(JBCStack2FEHelperTest, Dup2X1_Correct_S2) {
+  helper.SetNStacks(6);
+  helper.ClearStack();
+  // before: Reg0_ref, Reg1_i32, Reg2_i64 ->
+  // after:  Reg0_ref, Reg2_i64, Reg1_i32, Reg2_i64 ->
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(0), PTY_ref), true);
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(1), PTY_i32), true);
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(2), PTY_i64), true);
+  EXPECT_EQ(helper.DumpStackInJavaFormat(), "RIJJ");
+  EXPECT_EQ(helper.DumpStackInInternalFormat(), "NNWD");
+  EXPECT_EQ(helper.Dup(jbc::kOpDup2X1), true);
+  EXPECT_EQ(helper.DumpStackInJavaFormat(), "RJJIJJ");
+  EXPECT_EQ(helper.DumpStackInInternalFormat(), "NWDNWD");
+  PrimType pty;
+  UniqueFEIRVar var1 = helper.PopItemAuto(pty);
+  EXPECT_EQ(pty, PTY_i64);
+  EXPECT_EQ(var1->GetNameRaw(), "Reg2");
+  UniqueFEIRVar var2 = helper.PopItemAuto(pty);
+  EXPECT_EQ(pty, PTY_i32);
+  EXPECT_EQ(var2->GetNameRaw(), "Reg1");
+  UniqueFEIRVar var3 = helper.PopItemAuto(pty);
+  EXPECT_EQ(pty, PTY_i64);
+  EXPECT_EQ(var3->GetNameRaw(), "Reg2");
+}
+
+TEST_F(JBCStack2FEHelperTest, Dup2X2_Correct_S1) {
+  helper.SetNStacks(8);
+  helper.ClearStack();
+  // before: Reg0_ref, Reg1_i32, Reg2_f32, Reg3_i32, Reg4_ref ->
+  // after:  Reg0_ref, Reg3_i32, Reg4_ref, Reg1_i32, Reg2_f32, Reg3_i32, Reg4_ref ->
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(0), PTY_ref), true);
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(1), PTY_i32), true);
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(2), PTY_f32), true);
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(3), PTY_i32), true);
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(4), PTY_ref), true);
+  EXPECT_EQ(helper.DumpStackInJavaFormat(), "RIFIR");
+  EXPECT_EQ(helper.DumpStackInInternalFormat(), "NNNNN");
+  EXPECT_EQ(helper.Dup(jbc::kOpDup2X2), true);
+  EXPECT_EQ(helper.DumpStackInJavaFormat(), "RIRIFIR");
+  EXPECT_EQ(helper.DumpStackInInternalFormat(), "NNNNNNN");
+  PrimType pty;
+  UniqueFEIRVar var1 = helper.PopItemAuto(pty);
+  EXPECT_EQ(pty, PTY_ref);
+  EXPECT_EQ(var1->GetNameRaw(), "Reg4");
+  UniqueFEIRVar var2 = helper.PopItemAuto(pty);
+  EXPECT_EQ(pty, PTY_i32);
+  EXPECT_EQ(var2->GetNameRaw(), "Reg3");
+  UniqueFEIRVar var3 = helper.PopItemAuto(pty);
+  EXPECT_EQ(pty, PTY_f32);
+  EXPECT_EQ(var3->GetNameRaw(), "Reg2");
+  UniqueFEIRVar var4 = helper.PopItemAuto(pty);
+  EXPECT_EQ(pty, PTY_i32);
+  EXPECT_EQ(var4->GetNameRaw(), "Reg1");
+  UniqueFEIRVar var5 = helper.PopItemAuto(pty);
+  EXPECT_EQ(pty, PTY_ref);
+  EXPECT_EQ(var5->GetNameRaw(), "Reg4");
+  UniqueFEIRVar var6 = helper.PopItemAuto(pty);
+  EXPECT_EQ(pty, PTY_i32);
+  EXPECT_EQ(var6->GetNameRaw(), "Reg3");
+}
+
+TEST_F(JBCStack2FEHelperTest, Dup2X2_Correct_S2) {
+  helper.SetNStacks(8);
+  helper.ClearStack();
+  // before: Reg0_ref, Reg1_i32, Reg2_f32, Reg3_i64 ->
+  // after:  Reg0_ref, Reg3_i64, Reg1_i32, Reg2_f32, Reg3_i64 ->
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(0), PTY_ref), true);
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(1), PTY_i32), true);
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(2), PTY_f32), true);
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(3), PTY_i64), true);
+  EXPECT_EQ(helper.DumpStackInJavaFormat(), "RIFJJ");
+  EXPECT_EQ(helper.DumpStackInInternalFormat(), "NNNWD");
+  EXPECT_EQ(helper.Dup(jbc::kOpDup2X2), true);
+  EXPECT_EQ(helper.DumpStackInJavaFormat(), "RJJIFJJ");
+  EXPECT_EQ(helper.DumpStackInInternalFormat(), "NWDNNWD");
+  PrimType pty;
+  UniqueFEIRVar var1 = helper.PopItemAuto(pty);
+  EXPECT_EQ(pty, PTY_i64);
+  EXPECT_EQ(var1->GetNameRaw(), "Reg3");
+  UniqueFEIRVar var2 = helper.PopItemAuto(pty);
+  EXPECT_EQ(pty, PTY_f32);
+  EXPECT_EQ(var2->GetNameRaw(), "Reg2");
+  UniqueFEIRVar var3 = helper.PopItemAuto(pty);
+  EXPECT_EQ(pty, PTY_i32);
+  EXPECT_EQ(var3->GetNameRaw(), "Reg1");
+  UniqueFEIRVar var4 = helper.PopItemAuto(pty);
+  EXPECT_EQ(pty, PTY_i64);
+  EXPECT_EQ(var4->GetNameRaw(), "Reg3");
+}
+
+TEST_F(JBCStack2FEHelperTest, Dup2X2_Correct_S3) {
+  helper.SetNStacks(8);
+  helper.ClearStack();
+  // before: Reg0_ref, Reg1_i64, Reg3_i32, Reg4_f32 ->
+  // after:  Reg0_ref, Reg3_i32, Reg4_f32, Reg1_i64, Reg3_i32, Reg4_f32 ->
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(0), PTY_ref), true);
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(1), PTY_i64), true);
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(3), PTY_i32), true);
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(4), PTY_f32), true);
+  EXPECT_EQ(helper.DumpStackInJavaFormat(), "RJJIF");
+  EXPECT_EQ(helper.DumpStackInInternalFormat(), "NWDNN");
+  EXPECT_EQ(helper.Dup(jbc::kOpDup2X2), true);
+  EXPECT_EQ(helper.DumpStackInJavaFormat(), "RIFJJIF");
+  EXPECT_EQ(helper.DumpStackInInternalFormat(), "NNNWDNN");
+  PrimType pty;
+  UniqueFEIRVar var1 = helper.PopItemAuto(pty);
+  EXPECT_EQ(pty, PTY_f32);
+  EXPECT_EQ(var1->GetNameRaw(), "Reg4");
+  UniqueFEIRVar var2 = helper.PopItemAuto(pty);
+  EXPECT_EQ(pty, PTY_i32);
+  EXPECT_EQ(var2->GetNameRaw(), "Reg3");
+  UniqueFEIRVar var3 = helper.PopItemAuto(pty);
+  EXPECT_EQ(pty, PTY_i64);
+  EXPECT_EQ(var3->GetNameRaw(), "Reg1");
+  UniqueFEIRVar var4 = helper.PopItemAuto(pty);
+  EXPECT_EQ(pty, PTY_f32);
+  EXPECT_EQ(var4->GetNameRaw(), "Reg4");
+  UniqueFEIRVar var5 = helper.PopItemAuto(pty);
+  EXPECT_EQ(pty, PTY_i32);
+  EXPECT_EQ(var5->GetNameRaw(), "Reg3");
+}
+
+TEST_F(JBCStack2FEHelperTest, Dup2X2_Correct_S4) {
+  helper.SetNStacks(8);
+  helper.ClearStack();
+  // before: Reg0_ref, Reg1_i64, Reg3_f64 ->
+  // after:  Reg0_ref, Reg3_f64, Reg1_i64, Reg3_f64 ->
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(0), PTY_ref), true);
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(1), PTY_i64), true);
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(3), PTY_f64), true);
+  EXPECT_EQ(helper.DumpStackInJavaFormat(), "RJJDD");
+  EXPECT_EQ(helper.DumpStackInInternalFormat(), "NWDWD");
+  EXPECT_EQ(helper.Dup(jbc::kOpDup2X2), true);
+  EXPECT_EQ(helper.DumpStackInJavaFormat(), "RDDJJDD");
+  EXPECT_EQ(helper.DumpStackInInternalFormat(), "NWDWDWD");
+  PrimType pty;
+  UniqueFEIRVar var1 = helper.PopItemAuto(pty);
+  EXPECT_EQ(pty, PTY_f64);
+  EXPECT_EQ(var1->GetNameRaw(), "Reg3");
+  UniqueFEIRVar var2 = helper.PopItemAuto(pty);
+  EXPECT_EQ(pty, PTY_i64);
+  EXPECT_EQ(var2->GetNameRaw(), "Reg1");
+  UniqueFEIRVar var3 = helper.PopItemAuto(pty);
+  EXPECT_EQ(pty, PTY_f64);
+  EXPECT_EQ(var3->GetNameRaw(), "Reg3");
+}
+
+TEST_F(JBCStack2FEHelperTest, GenerateSwapStmts_Test1) {
+  helper.SetNStacks(5);
+  helper.SetNSwaps(5);
+  helper.ClearStack();
+  // stack: Reg0_i32, Ref1_i64, Reg3_f64
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(0, PTY_i32), PTY_i32), true);
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(1, PTY_i64), PTY_i64), true);
+  EXPECT_EQ(helper.PushItem(std::make_unique<FEIRVarReg>(3, PTY_f64), PTY_f64), true);
+  std::list<UniqueFEIRStmt> stmts = helper.GenerateSwapStmts();
+  ASSERT_EQ(stmts.size(), 3);
+  std::list<UniqueFEIRStmt>::iterator it = stmts.begin();
+  std::list<StmtNode*> mirStmts0 = it->get()->GenMIRStmts(mirBuilder);
+  it++;
+  std::list<StmtNode*> mirStmts1 = it->get()->GenMIRStmts(mirBuilder);
+  it++;
+  std::list<StmtNode*> mirStmts2 = it->get()->GenMIRStmts(mirBuilder);
+
+  RedirectCout();
+  // stmt 0: dassign %Reg5_f64 0 (dread f64 %Reg3_f64)
+  ASSERT_EQ(mirStmts0.size(), 1);
+  mirStmts0.front()->Dump();
+  std::string dumpStr = GetBufferString();
+  std::string pattern = std::string("dassign %Reg5_f64 0 \\(dread f64 %Reg3_f64\\)") + MPLFEUTRegx::Any();
+  EXPECT_EQ(MPLFEUTRegx::Match(dumpStr, pattern), true);
+
+  // stmt 1: dassign %Reg7_i64 0 (dread i64 %Reg1_i64)
+  ClearBufferString();
+  ASSERT_EQ(mirStmts1.size(), 1);
+  mirStmts1.front()->Dump();
+  dumpStr = GetBufferString();
+  pattern = std::string("dassign %Reg7_i64 0 \\(dread i64 %Reg1_i64\\)") + MPLFEUTRegx::Any();
+  EXPECT_EQ(MPLFEUTRegx::Match(dumpStr, pattern), true);
+
+  // stmt 2: dassign %Reg9_i32 0 (dread i32 %Reg0_i32)
+  ClearBufferString();
+  ASSERT_EQ(mirStmts2.size(), 1);
+  mirStmts2.front()->Dump();
+  dumpStr = GetBufferString();
+  pattern = std::string("dassign %Reg9_i32 0 \\(dread i32 %Reg0_i32\\)") + MPLFEUTRegx::Any();
+  EXPECT_EQ(MPLFEUTRegx::Match(dumpStr, pattern), true);
+  RestoreCout();
+}
+
+TEST_F(JBCStack2FEHelperTest, LoadSwapStack_Test1) {
+  stackHelper.Reset();
+  helper.SetNStacks(5);
+  helper.SetNSwaps(5);
+  stackHelper.PushItem(jbc::JBCPrimType::kTypeInt);
+  stackHelper.PushItem(jbc::JBCPrimType::kTypeLong);
+  stackHelper.PushItem(jbc::JBCPrimType::kTypeDouble);
+  bool success;
+  std::list<UniqueFEIRStmt> stmts = helper.LoadSwapStack(stackHelper, success);
+  EXPECT_EQ(success, true);
+  ASSERT_EQ(stmts.size(), 3);
+  std::list<UniqueFEIRStmt>::iterator it = stmts.begin();
+  std::list<StmtNode*> mirStmts0 = it->get()->GenMIRStmts(mirBuilder);
+  it++;
+  std::list<StmtNode*> mirStmts1 = it->get()->GenMIRStmts(mirBuilder);
+  it++;
+  std::list<StmtNode*> mirStmts2 = it->get()->GenMIRStmts(mirBuilder);
+
+  // swap detail
+  // swap stack: Reg9_i32, Reg7_i64, Reg5_f64
+  // jbc stack:  Reg0_i32, Reg1_i64, Reg3_f64
+
+  // stack check
+  PrimType pty;
+  UniqueFEIRVar var1 = helper.PopItemAuto(pty);
+  EXPECT_EQ(pty, PTY_f64);
+  EXPECT_EQ(var1->GetNameRaw(), "Reg3");
+  UniqueFEIRVar var2 = helper.PopItemAuto(pty);
+  EXPECT_EQ(pty, PTY_i64);
+  EXPECT_EQ(var2->GetNameRaw(), "Reg1");
+  UniqueFEIRVar var3 = helper.PopItemAuto(pty);
+  EXPECT_EQ(pty, PTY_i32);
+  EXPECT_EQ(var3->GetNameRaw(), "Reg0");
+
+  // stmts check
+  RedirectCout();
+  // stmt 0: dassign %Reg0_i32 0 (dread i32 %Reg9_i32)
+  ASSERT_EQ(mirStmts0.size(), 1);
+  mirStmts0.front()->Dump();
+  std::string dumpStr = GetBufferString();
+  std::string pattern = std::string("dassign %Reg0_i32 0 \\(dread i32 %Reg9_i32\\)") + MPLFEUTRegx::Any();
+  EXPECT_EQ(MPLFEUTRegx::Match(dumpStr, pattern), true);
+
+  // stmt 1: dassign %Reg1_i64 0 (dread i64 %Reg7_i64)
+  ClearBufferString();
+  ASSERT_EQ(mirStmts1.size(), 1);
+  mirStmts1.front()->Dump();
+  dumpStr = GetBufferString();
+  pattern = std::string("dassign %Reg1_i64 0 \\(dread i64 %Reg7_i64\\)") + MPLFEUTRegx::Any();
+  EXPECT_EQ(MPLFEUTRegx::Match(dumpStr, pattern), true);
+
+  // stmt 2: dassign %Reg3_f64 0 (dread f64 %Reg5_f64)
+  ClearBufferString();
+  ASSERT_EQ(mirStmts2.size(), 1);
+  mirStmts2.front()->Dump();
+  dumpStr = GetBufferString();
+  pattern = std::string("dassign %Reg3_f64 0 \\(dread f64 %Reg5_f64\\)") + MPLFEUTRegx::Any();
+  EXPECT_EQ(MPLFEUTRegx::Match(dumpStr, pattern), true);
+  RestoreCout();
+}
+}  // namespace maple
\ No newline at end of file
diff --git a/src/mplfe/test/jbc_stack_helper_test.cpp b/src/mplfe/test/jbc_stack_helper_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..3dcbfe5bc68a5c6bab946076e71f01336b87194c
--- /dev/null
+++ b/src/mplfe/test/jbc_stack_helper_test.cpp
@@ -0,0 +1,234 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v1 for more details.
+ */
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+#include "jbc_stack_helper.h"
+
+namespace maple {
+TEST(JBCStackHelper, PushItem_PopItem) {
+  JBCStackHelper stackHelper;
+  stackHelper.PushItem(jbc::JBCPrimType::kTypeInt);
+  EXPECT_EQ(stackHelper.PopItem(jbc::JBCPrimType::kTypeInt), true);
+  stackHelper.Reset();
+  stackHelper.PushItem(jbc::JBCPrimType::kTypeInt);
+  EXPECT_EQ(stackHelper.PopItem(jbc::JBCPrimType::kTypeFloat), false);
+  stackHelper.Reset();
+  stackHelper.PushItem(jbc::JBCPrimType::kTypeLong);
+  EXPECT_EQ(stackHelper.PopItem(jbc::JBCPrimType::kTypeInt), false);
+  stackHelper.Reset();
+  stackHelper.PushItem(jbc::JBCPrimType::kTypeLong);
+  EXPECT_EQ(stackHelper.PopItem(jbc::JBCPrimType::kTypeLong), true);
+  stackHelper.Reset();
+  stackHelper.PushItem(jbc::JBCPrimType::kTypeDouble);
+  EXPECT_EQ(stackHelper.PopItem(jbc::JBCPrimType::kTypeDouble), true);
+  stackHelper.Reset();
+  EXPECT_EQ(stackHelper.PopItem(jbc::JBCPrimType::kTypeDouble), false);
+}
+
+TEST(JBCStackHelper, Dup) {
+  JBCStackHelper stackHelper;
+  stackHelper.PushItem(jbc::JBCPrimType::kTypeInt);
+  EXPECT_EQ(stackHelper.Dup(jbc::kOpDup), true);
+  std::vector<jbc::JBCPrimType> types({ jbc::JBCPrimType::kTypeInt, jbc::JBCPrimType::kTypeInt });
+  EXPECT_EQ(stackHelper.PopItems(types), true);
+
+  stackHelper.Reset();
+  EXPECT_EQ(stackHelper.Dup(jbc::kOpDup), false);
+
+  stackHelper.Reset();
+  stackHelper.PushItem(jbc::JBCPrimType::kTypeLong);
+  EXPECT_EQ(stackHelper.Dup(jbc::kOpDup), false);
+}
+
+TEST(JBCStackHelper, DupX1) {
+  JBCStackHelper stackHelper;
+  stackHelper.PushItem(jbc::JBCPrimType::kTypeInt);
+  stackHelper.PushItem(jbc::JBCPrimType::kTypeFloat);
+  EXPECT_EQ(stackHelper.Dup(jbc::kOpDupX1), true);
+  std::vector<jbc::JBCPrimType> types({ jbc::JBCPrimType::kTypeFloat, jbc::JBCPrimType::kTypeInt,
+                                        jbc::JBCPrimType::kTypeFloat });
+  EXPECT_EQ(stackHelper.PopItems(types), true);
+
+  stackHelper.Reset();
+  EXPECT_EQ(stackHelper.Dup(jbc::kOpDupX1), false);
+
+  stackHelper.Reset();
+  stackHelper.PushItem(jbc::JBCPrimType::kTypeInt);
+  EXPECT_EQ(stackHelper.Dup(jbc::kOpDupX1), false);
+
+  stackHelper.Reset();
+  stackHelper.PushItem(jbc::JBCPrimType::kTypeLong);
+  EXPECT_EQ(stackHelper.Dup(jbc::kOpDupX1), false);
+
+  stackHelper.Reset();
+  stackHelper.PushItem(jbc::JBCPrimType::kTypeInt);
+  stackHelper.PushItem(jbc::JBCPrimType::kTypeLong);
+  EXPECT_EQ(stackHelper.Dup(jbc::kOpDupX1), false);
+
+  stackHelper.Reset();
+  stackHelper.PushItem(jbc::JBCPrimType::kTypeLong);
+  stackHelper.PushItem(jbc::JBCPrimType::kTypeInt);
+  EXPECT_EQ(stackHelper.Dup(jbc::kOpDupX1), false);
+
+  stackHelper.Reset();
+  stackHelper.PushItem(jbc::JBCPrimType::kTypeLong);
+  stackHelper.PushItem(jbc::JBCPrimType::kTypeLong);
+  EXPECT_EQ(stackHelper.Dup(jbc::kOpDupX1), false);
+}
+
+TEST(JBCStackHelper, DupX2) {
+  JBCStackHelper stackHelper;
+  // mode 1: ..., typeI, typeI, typeI ->
+  // input: ..., I, S, B ->
+  // output: ..., B, I, S, B ->
+  stackHelper.PushItem(jbc::JBCPrimType::kTypeInt);
+  stackHelper.PushItem(jbc::JBCPrimType::kTypeShort);
+  stackHelper.PushItem(jbc::JBCPrimType::kTypeByteOrBoolean);
+  EXPECT_EQ(stackHelper.Dup(jbc::kOpDupX2), true);
+  std::vector<jbc::JBCPrimType> types1({ jbc::JBCPrimType::kTypeByteOrBoolean, jbc::JBCPrimType::kTypeInt,
+                                         jbc::JBCPrimType::kTypeShort, jbc::JBCPrimType::kTypeByteOrBoolean });
+  EXPECT_EQ(stackHelper.PopItems(types1), true);
+
+  // mode2: ..., typeII, typeI ->
+  // input: ..., J, I ->
+  // output: ..., I, J, I ->
+  stackHelper.Reset();
+  stackHelper.PushItem(jbc::JBCPrimType::kTypeLong);
+  stackHelper.PushItem(jbc::JBCPrimType::kTypeInt);
+  EXPECT_EQ(stackHelper.Dup(jbc::kOpDupX2), true);
+  std::vector<jbc::JBCPrimType> types2({ jbc::JBCPrimType::kTypeInt, jbc::JBCPrimType::kTypeLong,
+                                         jbc::JBCPrimType::kTypeInt });
+  EXPECT_EQ(stackHelper.PopItems(types2), true);
+
+  // TODO(UT): add false cases
+}
+
+TEST(JBCStackHelper, Dup2) {
+  JBCStackHelper stackHelper;
+  // mode 1: ..., typeI, typeI ->
+  // input: ..., I, S ->
+  // output: ..., I, S, I, S ->
+  stackHelper.PushItem(jbc::JBCPrimType::kTypeInt);
+  stackHelper.PushItem(jbc::JBCPrimType::kTypeShort);
+  EXPECT_EQ(stackHelper.Dup(jbc::kOpDup2), true);
+  std::vector<jbc::JBCPrimType> types1({ jbc::JBCPrimType::kTypeInt, jbc::JBCPrimType::kTypeShort,
+                                         jbc::JBCPrimType::kTypeInt, jbc::JBCPrimType::kTypeShort });
+  EXPECT_EQ(stackHelper.PopItems(types1), true);
+
+  // mode 2: ..., typeII ->
+  // input: ..., J ->
+  // output: ..., J, J ->
+  stackHelper.Reset();
+  stackHelper.PushItem(jbc::JBCPrimType::kTypeLong);
+  EXPECT_EQ(stackHelper.Dup(jbc::kOpDup2), true);
+  std::vector<jbc::JBCPrimType> types2({ jbc::JBCPrimType::kTypeLong, jbc::JBCPrimType::kTypeLong });
+  EXPECT_EQ(stackHelper.PopItems(types2), true);
+
+  // TODO(UT): add false cases
+}
+
+TEST(JBCStackHelper, Dup2X1) {
+  JBCStackHelper stackHelper;
+  // mode 1: ..., typeI, typeI, typeI ->
+  // input: ..., I, S, B ->
+  // output: ..., S, B, I, S, B ->
+  stackHelper.PushItem(jbc::JBCPrimType::kTypeInt);
+  stackHelper.PushItem(jbc::JBCPrimType::kTypeShort);
+  stackHelper.PushItem(jbc::JBCPrimType::kTypeByteOrBoolean);
+  EXPECT_EQ(stackHelper.Dup(jbc::kOpDup2X1), true);
+  std::vector<jbc::JBCPrimType> types1({ jbc::JBCPrimType::kTypeShort, jbc::JBCPrimType::kTypeByteOrBoolean,
+                                         jbc::JBCPrimType::kTypeInt, jbc::JBCPrimType::kTypeShort,
+                                         jbc::JBCPrimType::kTypeByteOrBoolean });
+  EXPECT_EQ(stackHelper.PopItems(types1), true);
+
+  // mode 2: ..., typeI, typeII ->
+  // input: ..., I, J ->
+  // output: ..., J, I, J ->
+  stackHelper.Reset();
+  stackHelper.PushItem(jbc::JBCPrimType::kTypeInt);
+  stackHelper.PushItem(jbc::JBCPrimType::kTypeLong);
+  EXPECT_EQ(stackHelper.Dup(jbc::kOpDup2X1), true);
+  std::vector<jbc::JBCPrimType> types2({ jbc::JBCPrimType::kTypeLong, jbc::JBCPrimType::kTypeInt,
+                                         jbc::JBCPrimType::kTypeLong });
+  EXPECT_EQ(stackHelper.PopItems(types2), true);
+
+  // TODO(UT): add false cases
+}
+
+TEST(JBCStackHelper, Dup2X2) {
+  JBCStackHelper stackHelper;
+  // mode 1: ..., typeI, typeI, typeI, typeI ->
+  // input: ..., I, S, B, C ->
+  // output: ..., B, C, I, S, B, C ->
+  stackHelper.PushItem(jbc::JBCPrimType::kTypeInt);
+  stackHelper.PushItem(jbc::JBCPrimType::kTypeShort);
+  stackHelper.PushItem(jbc::JBCPrimType::kTypeByteOrBoolean);
+  stackHelper.PushItem(jbc::JBCPrimType::kTypeChar);
+  EXPECT_EQ(stackHelper.Dup(jbc::kOpDup2X2), true);
+  std::vector<jbc::JBCPrimType> types1({ jbc::JBCPrimType::kTypeByteOrBoolean, jbc::JBCPrimType::kTypeChar,
+                                         jbc::JBCPrimType::kTypeInt, jbc::JBCPrimType::kTypeShort,
+                                         jbc::JBCPrimType::kTypeByteOrBoolean, jbc::JBCPrimType::kTypeChar });
+  EXPECT_EQ(stackHelper.PopItems(types1), true);
+
+  // mode 2: ..., typeI, typeI, typeII ->
+  // input: ..., I, S, J ->
+  // output: ..., J, I, S, J ->
+  stackHelper.Reset();
+  stackHelper.PushItem(jbc::JBCPrimType::kTypeInt);
+  stackHelper.PushItem(jbc::JBCPrimType::kTypeShort);
+  stackHelper.PushItem(jbc::JBCPrimType::kTypeLong);
+  EXPECT_EQ(stackHelper.Dup(jbc::kOpDup2X2), true);
+  std::vector<jbc::JBCPrimType> types2({ jbc::JBCPrimType::kTypeLong, jbc::JBCPrimType::kTypeInt,
+                                         jbc::JBCPrimType::kTypeShort, jbc::JBCPrimType::kTypeLong });
+  EXPECT_EQ(stackHelper.PopItems(types2), true);
+
+  // mode 3: ..., typeII, typeI, typeI ->
+  // input: ..., J, I, S ->
+  // output: ..., I, S, J, I, S ->
+  stackHelper.Reset();
+  stackHelper.PushItem(jbc::JBCPrimType::kTypeLong);
+  stackHelper.PushItem(jbc::JBCPrimType::kTypeInt);
+  stackHelper.PushItem(jbc::JBCPrimType::kTypeShort);
+  EXPECT_EQ(stackHelper.Dup(jbc::kOpDup2X2), true);
+  std::vector<jbc::JBCPrimType> types3({ jbc::JBCPrimType::kTypeInt, jbc::JBCPrimType::kTypeShort,
+                                         jbc::JBCPrimType::kTypeLong, jbc::JBCPrimType::kTypeInt,
+                                         jbc::JBCPrimType::kTypeShort });
+  EXPECT_EQ(stackHelper.PopItems(types3), true);
+
+  // mode 4: ..., typeII, typeII ->
+  // input: ..., J, D ->
+  // output: ..., D, J, D ->
+  stackHelper.Reset();
+  stackHelper.PushItem(jbc::JBCPrimType::kTypeLong);
+  stackHelper.PushItem(jbc::JBCPrimType::kTypeDouble);
+  EXPECT_EQ(stackHelper.Dup(jbc::kOpDup2X2), true);
+  std::vector<jbc::JBCPrimType> types4({ jbc::JBCPrimType::kTypeDouble, jbc::JBCPrimType::kTypeLong,
+                                         jbc::JBCPrimType::kTypeDouble });
+  EXPECT_EQ(stackHelper.PopItems(types4), true);
+
+  // TODO(UT): add false cases
+}
+
+TEST(JBCStackHelper, Swap) {
+  JBCStackHelper stackHelper;
+  stackHelper.PushItem(jbc::JBCPrimType::kTypeInt);
+  stackHelper.PushItem(jbc::JBCPrimType::kTypeShort);
+  EXPECT_EQ(stackHelper.Swap(), true);
+  std::vector<jbc::JBCPrimType> types({ jbc::JBCPrimType::kTypeShort, jbc::JBCPrimType::kTypeInt });
+  EXPECT_EQ(stackHelper.PopItems(types), true);
+
+  // TODO(UT): add false cases
+}
+}  // namespace maple
\ No newline at end of file
diff --git a/src/mplfe/test/jbc_util_test.cpp b/src/mplfe/test/jbc_util_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..c21469010f79812b13c376dabc8c28f6a49f70dc
--- /dev/null
+++ b/src/mplfe/test/jbc_util_test.cpp
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v1 for more details.
+ */
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+#include "jbc_util.h"
+
+namespace maple {
+namespace jbc {
+TEST(JBCUtil, ClassInternalNameToFullName) {
+  EXPECT_EQ(JBCUtil::ClassInternalNameToFullName("java/lang/Object"), "Ljava/lang/Object;");
+  EXPECT_EQ(JBCUtil::ClassInternalNameToFullName("[Ljava/lang/Object;"), "[Ljava/lang/Object;");
+}
+
+TEST(JBCUtil, SolveMethodSignature) {
+  std::vector<std::string> ans;
+  ans = JBCUtil::SolveMethodSignature("func(Ljava/lang/Object;[II)J");
+  ASSERT_EQ(ans.size(), 4);
+  EXPECT_EQ(ans[0], "J");
+  EXPECT_EQ(ans[1], "Ljava/lang/Object;");
+  EXPECT_EQ(ans[2], "[I");
+  EXPECT_EQ(ans[3], "I");
+}
+}  // namespace jbc
+}  // namespace maple
\ No newline at end of file
diff --git a/src/mplfe/test/mplfeUT.cpp b/src/mplfe/test/mplfeUT.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..10c19cf916a12844d4a3cb69afe140589a8f6fd8
--- /dev/null
+++ b/src/mplfe/test/mplfeUT.cpp
@@ -0,0 +1,89 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v1 for more details.
+ */
+#include <gtest/gtest.h>
+#include <iostream>
+#include "mpl_logging.h"
+#include "mir_module.h"
+#include "mplfe_ut_options.h"
+#include "basic_io.h"
+#include "base64.h"
+#include "jbc_input.h"
+#include "fe_manager.h"
+#include "fe_file_type.h"
+#include "fe_type_hierarchy.h"
+#include "mplfe_ut_environment.h"
+
+using namespace maple;
+void GenBase64ForFile(const std::string &fileName) {
+  BasicIOMapFile file(fileName);
+  if (!file.OpenAndMap()) {
+    FATAL(kLncFatal, "Can not open the input file %s for base64 convert.", fileName.c_str());
+  }
+  std::string base64Str = Base64::Encode(file.GetPtr(), file.GetLength());
+  size_t length = base64Str.length();
+  size_t start = 0;
+  const size_t width = 60;
+  while (start < length) {
+    std::cout << "\"" << base64Str.substr(start, width) << "\"" << std::endl;
+    start += width;
+  }
+  file.Close();
+}
+
+int main(int argc, char **argv) {
+  ::testing::AddGlobalTestEnvironment(new MPLFEUTEnvironment);
+  FEManager::Init(MPLFEUTEnvironment::GetMIRModule());
+  MPLFEUTOptions options;
+  if (!options.SolveArgs(argc, argv)) {
+    return 0;
+  }
+  if (options.GetRunAll()) {
+    if (argc > 1) {
+      argc--;
+      argv++;
+    }
+    testing::InitGoogleTest(&argc, argv);
+    return RUN_ALL_TESTS();
+  }
+  if (options.GetRunAllWithCore()) {
+    CHECK_FATAL(argc > 2, "In RunAllWithCore mode, argc must larger than 2");
+    argc -= 2;
+    argv += 2;
+    FEManager::GetTypeManager().LoadMplt(options.GetCoreMpltName(), FETypeFlag::kSrcMpltSys);
+    FETypeHierarchy::GetInstance().InitByGlobalTable();
+    testing::InitGoogleTest(&argc, argv);
+    return RUN_ALL_TESTS();
+  }
+  MPLFEUTEnvironment::GetMIRModule().SetFlavor(maple::kFeProduced);
+  MPLFEUTEnvironment::GetMIRModule().SetSrcLang(maple::kSrcLangJava);
+  if (options.GetGenBase64()) {
+    GenBase64ForFile(options.GetBase64SrcFileName());
+  }
+  jbc::JBCInput jbcInput(MPLFEUTEnvironment::GetMIRModule());
+  if (options.GetClassFileList().size() > 0) {
+    jbcInput.ReadClassFiles(options.GetClassFileList());
+  }
+  if (options.GetJarFileList().size() > 0) {
+    jbcInput.ReadJarFiles(options.GetJarFileList());
+  }
+  if (options.GetMpltFileList().size() > 0) {
+    if (FEManager::GetTypeManager().LoadMplts(options.GetMpltFileList(), FETypeFlag::kSrcMplt, "Load mplt")) {
+      INFO(kLncInfo, "Load mplt...success");
+    } else {
+      INFO(kLncInfo, "Load mplt...failed");
+    }
+  }
+  return 0;
+}
diff --git a/src/mplfe/test/mplfe_ut.h b/src/mplfe/test/mplfe_ut.h
new file mode 100644
index 0000000000000000000000000000000000000000..717f6cfaec372b79f238c5fb43fdba8a2b6aa068
--- /dev/null
+++ b/src/mplfe/test/mplfe_ut.h
@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v1 for more details.
+ */
+#ifndef MPLFEUT_INCLUDE_MPLFE_UT_H
+#define MPLFEUT_INCLUDE_MPLFE_UT_H
+#include "mir_module.h"
+
+extern maple::MIRModule &module;
+extern MPLFEUTOptions &options;
+#endif  // MPLFEUT_INCLUDE_MPLFE_UT_H
\ No newline at end of file
diff --git a/src/mplfe/test/mplfe_ut_environment.h b/src/mplfe/test/mplfe_ut_environment.h
new file mode 100644
index 0000000000000000000000000000000000000000..ba93987c001f5ff3525e084c974310b933e75009
--- /dev/null
+++ b/src/mplfe/test/mplfe_ut_environment.h
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v1 for more details.
+ */
+#ifndef MPLFE_TEST_MPLFE_UT_ENVIRONMENT_H
+#define MPLFE_TEST_MPLFE_UT_ENVIRONMENT_H
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+#include "global_tables.h"
+#include "mir_module.h"
+
+namespace maple {
+class MPLFEUTEnvironment : public ::testing::Environment {
+ public:
+  MPLFEUTEnvironment() = default;
+  ~MPLFEUTEnvironment() = default;
+
+  static MIRModule &GetMIRModule() {
+    static MIRModule module("mplfeUT");
+    return module;
+  }
+
+  void SetUp() override {
+    theMIRModule = &GetMIRModule();
+  }
+};
+}  // namespace maple
+#endif  // MPLFE_TEST_MPLFE_UT_ENVIRONMENT_H
\ No newline at end of file
diff --git a/src/mplfe/test/mplfe_ut_options.cpp b/src/mplfe/test/mplfe_ut_options.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..b0030b9e217f032d016357806f9b2b5c0f75f794
--- /dev/null
+++ b/src/mplfe/test/mplfe_ut_options.cpp
@@ -0,0 +1,137 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v1 for more details.
+ */
+#include "mplfe_ut_options.h"
+#include <iostream>
+#include "mpl_logging.h"
+#include "option_parser.h"
+#include "parser_opt.h"
+
+namespace maple {
+using namespace mapleOption;
+
+enum OptionIndex {
+  kMplfeUTHelp = kCommonOptionEnd + 1,   // -h
+  kGenBase64,                            // -genBase64
+  kInClass,                              // -in-class
+  kInJar,                                // -in-jar
+  kMplt,                                 // -mplt
+};
+
+const Descriptor kUsage[] = {
+  { kUnknown, 0, "", "", kBuildTypeAll, kArgCheckPolicyUnknown,
+    "========================================\n"
+    " Run gtest: mplfeUT\n"
+    " Run gtest: mplfeUT test [ options for gtest ]\n"
+    " Run ext mode: mplfeUT ext [ options ]\n"
+    "========= options for ext mode =========" },
+  { kHelp, 0, "h", "help", kBuildTypeAll, kArgCheckPolicyNone,
+    "  -h, --help                : print usage and exit", "mplfeUT", {} },
+  { kGenBase64, 0, "", "gen-base64", kBuildTypeAll, kArgCheckPolicyRequired,
+    "  -gen-base64 file.xx       : generate base64 string for file.xx", "mplfeUT", {} },
+  { kInClass, 0, "", "in-class", kBuildTypeAll, kArgCheckPolicyRequired,
+    "  -in-class file1.class,file2.class\n"
+    "                            : input class files", "mplfeUT", {} },
+  { kInJar, 0, "", "in-jar", kBuildTypeAll, kArgCheckPolicyRequired,
+    "  -in-jar file1.jar,file2.jar\n"
+    "                            : input jar files", "mplfeUT", {} },
+  { kMplt, 0, "", "mplt", kBuildTypeAll, kArgCheckPolicyRequired,
+    "  -mplt lib1.mplt,lib2.mplt\n"
+    "                            : input mplt files", "mplfeUT", {} },
+  { kUnknown, 0, "", "", kBuildTypeAll, kArgCheckPolicyNone, "", "mplfeUT", {} }
+};
+
+MPLFEUTOptions::MPLFEUTOptions()
+    : runAll(false),
+      runAllWithCore(false),
+      genBase64(false),
+      base64SrcFileName(""),
+      coreMpltName("") {
+        CreateUsages(kUsage);
+      }
+
+void MPLFEUTOptions::DumpUsage() const {
+  for (unsigned int i = 0; kUsage[i].help != ""; i++) {
+    std::cout << kUsage[i].help << std::endl;
+  }
+  exit(1);
+}
+
+bool MPLFEUTOptions::SolveArgs(int argc, char **argv) {
+  if (argc == 1) {
+    runAll = true;
+    return true;
+  }
+  if (std::string(argv[1]).compare("test") == 0) {
+    runAll = true;
+    return true;
+  }
+  if (std::string(argv[1]).compare("testWithMplt") == 0) {
+    runAllWithCore = true;
+    CHECK_FATAL(argc > 2, "In TestWithMplt mode, core.mplt must be specified");
+    coreMpltName = argv[2];
+    return true;
+  }
+  if (std::string(argv[1]).compare("ext") != 0) {
+    FATAL(kLncFatal, "Undefined mode");
+    return false;
+  }
+  runAll = false;
+  OptionParser optionParser;
+  optionParser.RegisteUsages(DriverOptionCommon::GetInstance());
+  optionParser.RegisteUsages(MPLFEUTOptions::GetInstance());
+
+  ErrorCode ret = optionParser.Parse(argc, argv, "mplfeUT");
+  if (ret != ErrorCode::kErrorNoError) {
+    DumpUsage();
+    return false;
+  }
+
+  for (auto opt : optionParser.GetOptions()) {
+    switch (opt.Index()) {
+      case kMplfeUTHelp:
+        DumpUsage();
+        return false;
+      case kGenBase64:
+        base64SrcFileName = opt.Args();
+        genBase64 = true;
+        break;
+      case kInClass:
+        Split(opt.Args(), ',', std::back_inserter(classFileList));
+        break;
+      case kInJar:
+        Split(opt.Args(), ',', std::back_inserter(jarFileList));
+        break;
+      case kMplt:
+        Split(opt.Args(), ',', std::back_inserter(mpltFileList));
+        break;
+      default:
+        FATAL(kLncFatal, "Unsupport option %s", opt.OptionKey().c_str());
+        DumpUsage();
+        return false;
+    }
+  }
+  return true;
+}
+
+template <typename Out>
+void MPLFEUTOptions::Split(const std::string &s, char delim, Out result) {
+  std::stringstream ss;
+  ss.str(s);
+  std::string item;
+  while (std::getline(ss, item, delim)) {
+    *(result++) = item;
+  }
+}
+}  // namespace maple
\ No newline at end of file
diff --git a/src/mplfe/test/mplfe_ut_options.h b/src/mplfe/test/mplfe_ut_options.h
new file mode 100644
index 0000000000000000000000000000000000000000..a21bbcad5df63c2528a061f931aafa74d914ae81
--- /dev/null
+++ b/src/mplfe/test/mplfe_ut_options.h
@@ -0,0 +1,80 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v1 for more details.
+ */
+#ifndef MPLFE_INCLUDE_MPLFE_UT_OPTIONS_H
+#define MPLFE_INCLUDE_MPLFE_UT_OPTIONS_H
+#include <string>
+#include <list>
+#include "driver_option_common.h"
+
+namespace maple {
+class MPLFEUTOptions : public maple::MapleDriverOptionBase {
+ public:
+  MPLFEUTOptions();
+  ~MPLFEUTOptions() = default;
+  void DumpUsage() const;
+  bool SolveArgs(int argc, char **argv);
+  template <typename Out>
+  static void Split(const std::string &s, char delim, Out result);
+
+  static MPLFEUTOptions &GetInstance() {
+    static MPLFEUTOptions options;
+    return options;
+  }
+
+  bool GetRunAll() const {
+    return runAll;
+  }
+
+  bool GetRunAllWithCore() const {
+    return runAllWithCore;
+  }
+
+  bool GetGenBase64() const {
+    return genBase64;
+  }
+
+  std::string GetBase64SrcFileName() const {
+    return base64SrcFileName;
+  }
+
+  std::string GetCoreMpltName() const {
+    return coreMpltName;
+  }
+
+  const std::list<std::string> &GetClassFileList() const {
+    return classFileList;
+  }
+
+  const std::list<std::string> &GetJarFileList() const {
+    return jarFileList;
+  }
+
+  const std::list<std::string> &GetMpltFileList() const {
+    return mpltFileList;
+  }
+
+ private:
+  bool runAll;
+  bool runAllWithCore;
+  bool genBase64;
+  std::string base64SrcFileName;
+  std::string coreMpltName;
+  std::list<std::string> classFileList;
+  std::list<std::string> jarFileList;
+  std::list<std::string> mpltFileList;
+};
+}  // namespace maple
+
+#endif  // MPLFE_INCLUDE_MPLFE_UT_OPTIONS_H
\ No newline at end of file
diff --git a/src/mplfe/test/mplfe_ut_regx.cpp b/src/mplfe/test/mplfe_ut_regx.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..237e69f02dfaafacd4797b2c8168e9b8c872c3d4
--- /dev/null
+++ b/src/mplfe/test/mplfe_ut_regx.cpp
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v1 for more details.
+ */
+#include "mplfe_ut_regx.h"
+#include <sstream>
+#include <iostream>
+
+namespace maple {
+bool MPLFEUTRegx::Match(const std::string &str, const std::string &pattern) {
+  if (std::regex_match(str, std::regex(pattern))) {
+    return true;
+  } else {
+    std::cerr << "Pattern: " << pattern << std::endl;
+    std::cerr << "String:  " << str << std::endl;
+    return false;
+  }
+}
+
+std::string MPLFEUTRegx::RegName(uint32 regNum) {
+  std::stringstream ss;
+  if (regNum == kAnyNumber) {
+    ss << "Reg[0-9]+";
+  } else {
+    ss << "Reg" << regNum;
+  }
+  return ss.str();
+}
+
+std::string MPLFEUTRegx::RefIndex(uint32 typeIdx) {
+  std::stringstream ss;
+  if (typeIdx == kAnyNumber) {
+    ss << "R[0-9]+";
+  } else {
+    ss << "R" << typeIdx;
+  }
+  return ss.str();
+}
+}  // namespace maple
\ No newline at end of file
diff --git a/src/mplfe/test/mplfe_ut_regx.h b/src/mplfe/test/mplfe_ut_regx.h
new file mode 100644
index 0000000000000000000000000000000000000000..ea7d6c99981fa43fc3027e1884ea2767dd0c2e07
--- /dev/null
+++ b/src/mplfe/test/mplfe_ut_regx.h
@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v1 for more details.
+ */
+#ifndef MPLFE_UT_INCLUDE_MPLFE_UT_REGX_H
+#define MPLFE_UT_INCLUDE_MPLFE_UT_REGX_H
+#include <string>
+#include <regex>
+#include "types_def.h"
+
+namespace maple {
+class MPLFEUTRegx {
+ public:
+  static const uint32 kAnyNumber = 0xFFFFFFFF;
+  MPLFEUTRegx() = default;
+  ~MPLFEUTRegx() = default;
+  static bool Match(const std::string &str, const std::string &pattern);
+  static std::string RegName(uint32 regNum);
+  static std::string RefIndex(uint32 typeIdx);
+  static std::string Any() {
+    return "(.|\r|\n)*";
+  }
+};
+}  // namespace maple
+#endif  // MPLFE_UT_INCLUDE_MPLFE_UT_REGX_H
\ No newline at end of file
diff --git a/src/mplfe/test/mplfe_ut_regx_test.cpp b/src/mplfe/test/mplfe_ut_regx_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..70a27954fef4c5fc0663d0859fb007174231333b
--- /dev/null
+++ b/src/mplfe/test/mplfe_ut_regx_test.cpp
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v1 for more details.
+ */
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+#include "mplfe_ut_regx.h"
+
+namespace maple {
+TEST(MPLFEUTRegx, Any) {
+  std::string pattern = MPLFEUTRegx::Any();
+  std::string str = "\n";
+  EXPECT_EQ(MPLFEUTRegx::Match(str, pattern), true);
+}
+
+TEST(MPLFEUTRegx, RegName) {
+  std::string patternAny = MPLFEUTRegx::RegName(MPLFEUTRegx::kAnyNumber);
+  std::string pattern100 = MPLFEUTRegx::RegName(100);
+  EXPECT_EQ(MPLFEUTRegx::Match("Reg100", patternAny), true);
+  EXPECT_EQ(MPLFEUTRegx::Match("Reg100", pattern100), true);
+  EXPECT_EQ(MPLFEUTRegx::Match("Reg1000", patternAny), true);
+  EXPECT_EQ(MPLFEUTRegx::Match("Reg1000", pattern100), false);
+}
+
+TEST(MPLFEUTRegx, RefIndex) {
+  std::string patternAny = MPLFEUTRegx::RefIndex(MPLFEUTRegx::kAnyNumber);
+  std::string pattern100 = MPLFEUTRegx::RefIndex(100);
+  EXPECT_EQ(MPLFEUTRegx::Match("R100", patternAny), true);
+  EXPECT_EQ(MPLFEUTRegx::Match("R100", pattern100), true);
+  EXPECT_EQ(MPLFEUTRegx::Match("R1000", patternAny), true);
+  EXPECT_EQ(MPLFEUTRegx::Match("R1000", pattern100), false);
+}
+}  // namespace maple
\ No newline at end of file
diff --git a/src/mplfe/test/ops_ut_check.sh b/src/mplfe/test/ops_ut_check.sh
new file mode 100644
index 0000000000000000000000000000000000000000..ba0f18b1db85b696e6b5d9e888f99575a627807f
--- /dev/null
+++ b/src/mplfe/test/ops_ut_check.sh
@@ -0,0 +1,28 @@
+#!/bin/bash
+#
+# Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+#
+# OpenArkCompiler is licensed under the Mulan PSL v1.
+# You can use this software according to the terms and conditions of the Mulan PSL v1.
+# You may obtain a copy of Mulan PSL v1 at:
+#
+#     http://license.coscl.org.cn/MulanPSL
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+# FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v1 for more details.
+#
+set -e
+
+JAVA_CORE=${MAPLE_ROOT}/libjava-core/java-core.jar
+cd ${MAPLE_ROOT}/libjava-core
+${MAPLE_ROOT}/output/bin/mplfe ${JAVA_CORE} -t -o java-core
+cd -
+rm -rf ${MAPLE_ROOT}/report
+${MAPLE_ROOT}/output/bin/mplfeUT ext -gen-base64 ${MAPLE_ROOT}/src/mplfe/test/jbc_input/JBC0001/Test.class
+${MAPLE_ROOT}/output/bin/mplfeUT ext -in-class ${MAPLE_ROOT}/src/mplfe/test/jbc_input/JBC0001/Test.class
+${MAPLE_ROOT}/output/bin/mplfeUT ext -in-jar ${JAVA_CORE}
+${MAPLE_ROOT}/output/bin/mplfeUT ext -mplt ${MAPLE_ROOT}/libjava-core/java-core.mplt
+${MAPLE_ROOT}/output/bin/mplfeUT testWithMplt ${MAPLE_ROOT}/libjava-core/java-core.mplt
+
diff --git a/src/mplfe/test/redirect_buffer.h b/src/mplfe/test/redirect_buffer.h
new file mode 100644
index 0000000000000000000000000000000000000000..53e1dea3f627640c58510d3dea5e179900aa873d
--- /dev/null
+++ b/src/mplfe/test/redirect_buffer.h
@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v1 for more details.
+ */
+#ifndef MPLFE_INCLUDE_REDIRECT_BUFFER_H
+#define MPLFE_INCLUDE_REDIRECT_BUFFER_H
+#include <sstream>
+#include <iostream>
+
+namespace maple {
+class RedirectBuffer {
+ public:
+  RedirectBuffer() : sbuf(std::cout.rdbuf()), outByErr(false) {}
+  ~RedirectBuffer() = default;
+
+  void RedirectCout(bool outByErrIn = false) {
+    sbuf = RedirectCoutBuf(ss.rdbuf());
+    ss.str("");
+    outByErr = outByErrIn;
+  }
+
+  void RestoreCout() {
+    ss.str("");
+    RedirectCoutBuf(sbuf);
+  }
+
+  std::string GetBufferString() {
+    std::string str = ss.str();
+    ss.str("");
+    if (outByErr) {
+      std::cerr << str;
+    }
+    return str;
+  }
+
+  void ClearBufferString() {
+    ss.str("");
+  }
+
+  std::string RemoveLastReturnChar(const std::string &input) {
+    size_t length = input.length();
+    while (input[length - 1] == '\n') {
+      length--;
+    }
+    return input.substr(0, length);
+  }
+
+ private:
+  std::stringstream ss;
+  std::streambuf *sbuf;
+  bool outByErr;
+
+  std::streambuf *RedirectCoutBuf(std::streambuf *newBuf) {
+    std::streambuf *streamBuf = std::cout.rdbuf();
+    std::cout.rdbuf(newBuf);
+    return streamBuf;
+  }
+};
+}  // namespace maple
+#endif  // MPLFE_INCLUDE_REDIRECT_BUFFER_H
\ No newline at end of file