docs: public static void logCoverageInformation(boolean logAdequatelyTested, boolean logInadequate, boolean logUnmappedLibnd4jOps,
                                                boolean logUntestedTFImport, boolean logUnmappedTFOps) {
          //Set of ops that we can't gradient check
          Set<Class> excludedFromBackpropCoverage = excludedFromGradientCheckCoverage();
          Set<Class> excludedFromAllTestCoverage = excludedFromAllTests();
  
          String numFormat = "%3d";
          int countAdequate = 0;
          int countAdequateBwd = 0;
          int countAdequateFwd = 0;
          if (logAdequatelyTested) {
              log.info(" --- Adequately Tested Classes ---");
              for (Class c : allOps) {
                  if(excludedFromAllTestCoverage.contains(c))
                      continue;
  
                  int countBackpropSeen = gradCheckCoverageCountPerClass.get(c);
                  int countFwdValidation = fwdPassCoverageCountPerClass.get(c) + singleOpTestCountPerClass.get(c);
  
                  if (countBackpropSeen > 0) {
                      countAdequateBwd++;
                  }
                  if (countFwdValidation > 0) {
                      countAdequateFwd++;
                  }
                  if (countFwdValidation > 0 && countBackpropSeen > 0) {
                      countAdequate++;
                  }
  
                  boolean gradExcluded = excludedFromBackpropCoverage.contains(c);
                  if (countFwdValidation > 0 && (countBackpropSeen > 0 || gradExcluded)) {
                      //At least 1 forward test, and 1 gradient check
  
                      if (gradExcluded) {
                          log.info("Forward: {} tests, GradCheck: <excluded> for op {}", String.format(numFormat, countFwdValidation), c.getName());
                      } else {
                          log.info("Forward: {} tests, GradCheck: {} tests  for op {}", String.format(numFormat, countFwdValidation),
                                  String.format(numFormat, countBackpropSeen), c.getName());
                      }
                  }
              }
          }
  
          if (logInadequate) {
              log.info(" --- Classes NOT Tested Adequately ---");
              for (Class c : allOps) {
                  if(excludedFromAllTestCoverage.contains(c))
                      continue;
                  int countBackpropSeen = gradCheckCoverageCountPerClass.get(c);
                  int countFwdValidation = fwdPassCoverageCountPerClass.get(c) + singleOpTestCountPerClass.get(c);
  
                  boolean gradExcluded = excludedFromBackpropCoverage.contains(c);
                  if (countFwdValidation == 0 || (countBackpropSeen == 0 && !gradExcluded)) {
                      //0 forward test OR 0 gradient check (and not excluded from grad checks)
  
                      if (gradExcluded) {
                          log.info("Forward: {} tests, GradCheck: <excluded> for op {}", String.format(numFormat, countFwdValidation), c.getName());
                      } else {
                          log.info("Forward: {} tests, GradCheck: {} tests  for op {}", String.format(numFormat, countFwdValidation),
                                  String.format(numFormat, countBackpropSeen), c.getName());
                      }
                  }
              }
          }
  
          if(logUnmappedLibnd4jOps ){
              log.info(" --- Libnd4j Ops Not Mapped ---");
              for(long l : nonMappedLibnd4jOps){
                  Pair<List<String>,CustomOpDescriptor> p = dedupedCustomOps.get(l);
                  log.info("Not mapped libnd4j custom op: {} (hash: {})", p.getFirst(), l);
              }
          }
  
          //Log info for TF import op coverage:
          Map<String,DifferentialFunction> tfOpsMap = DifferentialFunctionClassHolder.getInstance().getTensorFlowNames();
          int totalTFMappedOps = tfOpsMap.size();
          int tfOpsWithImportTests = 0;
          if(logUntestedTFImport)
              log.info(" --- Ops with TF Mapping but No TF Import Tests ---");
          List<String> tfOpsKeys = new ArrayList<>(tfOpsMap.keySet());
          Collections.sort(tfOpsKeys);
          Set<String> tfIgnored = excludeFromTfImportCoverage();
          int tfImportIgnored = 0;
          for(String s : tfOpsKeys){
              Integer count = tfMappedOpsImportTestCounts.get(s);
              if(count == null || count == 0){
                  if(tfIgnored.contains(s)){
                      tfImportIgnored++;
                  } else if(logUntestedTFImport)
                      log.info("TF mapped op with no import tests: {}", s);
              } else {
                  tfOpsWithImportTests++;
              }
          }
  
          if(logUnmappedTFOps){
              Map<String,OpDef> allTFOps;
              try{
                  allTFOps = TensorflowDescriptorParser.opDescs();
              } catch (Throwable t){
                  throw new RuntimeException(t);
              }
  
              List<String> notMapped = new ArrayList<>();
              for(String s : allTFOps.keySet()){
                  if(DifferentialFunctionClassHolder.getInstance().getOpWithTensorflowName(s) == null &&
                          !tfIgnored.contains(s)){
                      notMapped.add(s);
                  }
              }
  
              Collections.sort(notMapped);
              int subsets = (int)Math.ceil(notMapped.size() / 10);
              for( int i=0; i<subsets; i++ ){
                  log.info("TF ops not mapped for import: {}", notMapped.subList(10*i, Math.min(10*(i+1), notMapped.size())));
              }
          }
  
  
          int totalFwd = 0;
          for(Class c : allOps){
              if(!excludedFromAllTestCoverage.contains(c))
                  totalFwd++;
          }
          int totalBwd = 0;
          for (Class c : allOps) {
              if (!isBackpropOp(c)) {
                  totalBwd++;
              }
          }
  
          double fracFwdAdequate = countAdequateFwd / (double) totalFwd;
          double fracBwdAdequate = countAdequateBwd / (double) totalBwd;
          double fracAdequate = countAdequate / (double) allOps.size();
          String pcFwd = String.format("%.2f", fracFwdAdequate * 100.0);
          String pcBwd = String.format("%.2f", fracBwdAdequate * 100.0);
          String pc = String.format("%.2f", fracAdequate * 100.0);
  
          int countTf = DifferentialFunctionClassHolder.getInstance().getCountTotalTfOps();
          int countTfMapped = DifferentialFunctionClassHolder.getInstance().getCountTotalMappedOps();
          double tfFrac = countTfMapped / (double)countTf;
          String fracTfStr = String.format("%.2f", 100.0 * tfFrac);
  
          int countLibnd4jMapped = countTotalLibnd4jOps - nonMappedLibnd4jOps.size();
          String fracLibnd4j = String.format("%.2f", 100.0 * (countLibnd4jMapped / (double)countTotalLibnd4jOps));
  
          String fracTFMappedTested = String.format("%.2f", 100.0 * tfOpsWithImportTests / (double)(totalTFMappedOps-tfImportIgnored));
  
          log.info("*****************************************************");
          log.info("Op Validation:                        {} of {} classes with adequate tests ({}% coverage)", countAdequate, totalFwd, pc);
          log.info("Forward pass tests:                   {} of {} classes ({}% coverage)", countAdequateFwd, totalFwd, pcFwd);
          log.info("Gradient check tests:                 {} of {} classes ({}% coverage)", countAdequateBwd, totalBwd, pcBwd);
          log.info("({} ops excluded from gradient check coverage)", excludedFromBackpropCoverage.size());
          log.info("({} ops excluded from fwd+gradient tests)", excludedFromAllTestCoverage.size());
          log.info("TF mapped ops:                        {} of {} ({}%)", countTfMapped, countTf, fracTfStr);
          log.info("SD ops with TF import mapping + test  {} of {} ({}%) - {} ignored for coverage", tfOpsWithImportTests, (totalTFMappedOps-tfImportIgnored), fracTFMappedTested, tfImportIgnored);
          log.info("Libnd4j mapped ops:                   {} of {} ({}%)", countLibnd4jMapped, countTotalLibnd4jOps, fracLibnd4j);
          log.info("*****************************************************");
      }