return
	}

	// 3. Compare generated key with decrypted key
	if subtle.ConstantTimeCompare(key.Plaintext, decryptedKey) != 1 {
		response.DecryptionErr = "The generated and the decrypted data key do not match"
		resp, err := json.Marshal(response)
		if err != nil {
			writeCustomErrorResponseJSON(ctx, w, errorCodes.ToAPIErr(ErrInternalError), err.Error(), r.URL)
			return
		}
		writeSuccessResponseJSON(w, resp)

    try {
      return new CharSource() {
        @Override
        public Reader openStream() throws IOException {
          return new StringReader(string);
        }
      }.readLines();
    } catch (IOException e) {
      throw new AssertionError();
    }
  }

  @Override
  public void tearDown() throws IOException {
    factory.tearDown();
  }

        try {
            this.profileSelector = container.lookup(ProfileSelector.class);
            this.logger = ((MutablePlexusContainer) container).getLogger();
        } catch (ComponentLookupException e) {
            throw new IllegalStateException(e);
        }
        this.requestProperties = props;
    }

    @Override
    public Properties getRequestProperties() {

                    res.addEdge(sourceV, newV, edge);
                }
            }
            return findLinkedSubgraph(res);
        } catch (MetadataResolutionException e) {
            throw new GraphConflictResolutionException(e);
        }
    }

    // -------------------------------------------------------------------------------------

        assertTrue(exception instanceof Throwable);

        // Test that it can be caught as CIFSException
        boolean caughtAsCIFSException = false;
        try {
            throw exception;
        } catch (CIFSException e) {
            caughtAsCIFSException = true;
            assertEquals(exception, e);
        }
        assertTrue(caughtAsCIFSException);
    }

    @Test

	if numField != len(columnTypes) {
		t.Fatalf("column's number not match struct and ddl, %d != %d", numField, len(columnTypes))
	}
	namer := schema.NamingStrategy{}
	for i := 0; i < numField; i++ {
		expectName := namer.ColumnName("", typ.Field(i).Name)
		if columnTypes[i].Name() != expectName {
			t.Fatalf("column order not match struct and ddl, idx %d: %s != %s",
				i, columnTypes[i].Name(), expectName)
		}
	}

            result.setUpdatedBy(DfTypeUtil.toString(source.get("updatedBy")));
            result.setUpdatedTime(DfTypeUtil.toLong(source.get("updatedTime")));
            return updateEntity(source, result);
        } catch (InstantiationException | IllegalAccessException e) {
            final String msg = "Cannot create a new instance: " + entityType.getName();
            throw new IllegalBehaviorStateException(msg, e);
        }
    }

            result.setUpdatedTime(DfTypeUtil.toLong(source.get("updatedTime")));
            result.setUrlExpr(DfTypeUtil.toString(source.get("urlExpr")));
            return updateEntity(source, result);
        } catch (InstantiationException | IllegalAccessException e) {
            final String msg = "Cannot create a new instance: " + entityType.getName();
            throw new IllegalBehaviorStateException(msg, e);
        }
    }

            result.setUpdatedBy(DfTypeUtil.toString(source.get("updatedBy")));
            result.setUpdatedTime(DfTypeUtil.toLong(source.get("updatedTime")));
            return updateEntity(source, result);
        } catch (InstantiationException | IllegalAccessException e) {
            final String msg = "Cannot create a new instance: " + entityType.getName();
            throw new IllegalBehaviorStateException(msg, e);
        }
    }

            result.setStartTime(DfTypeUtil.toLong(source.get("startTime")));
            result.setTarget(DfTypeUtil.toString(source.get("target")));
            return updateEntity(source, result);
        } catch (InstantiationException | IllegalAccessException e) {
            final String msg = "Cannot create a new instance: " + entityType.getName();
            throw new IllegalBehaviorStateException(msg, e);
        }
    }