t.Errorf("Should got no error when creating data, but got %v", err)
	}

	if err := DB.Model(&data).Update("password", EncryptedData("xnewpass")).Error; err == nil {
		t.Errorf("Should failed to update data with invalid data")
	}

	if err := DB.Model(&data).Update("password", EncryptedData("newpass")).Error; err != nil {
		t.Errorf("Should got no error update data with valid data, but got %v", err)
	}

    assert response.status_code == 422, response.text

    data = {"items": [["foo", "bar"], ["baz"]]}
    response = client.post("/model-with-tuple/", json=data)
    assert response.status_code == 422, response.text


def test_tuple_with_model_valid():
    data = [{"x": 1, "y": 2}, {"x": 3, "y": 4}]
    response = client.post("/tuple-of-models/", json=data)
    assert response.status_code == 200, response.text

			}
			if withData {
				data, err := readConfig(ctx, objAPI, obj.Name)
				if err != nil {
					// ignore history file if not readable.
					continue
				}

				data, err = decryptData(data, obj.Name)
				if err != nil {
					// ignore history file that cannot be loaded.
					continue
				}

				cfgEntry.Data = string(data)
			}
			configHistory = append(configHistory, cfgEntry)

    }

    /**
     * Performs n-fold expansion of data as specified in RFC 3961.
     * This operation is used in Kerberos key derivation to expand or compress
     * input data to a specific output length.
     *
     * @param data the input data to expand
     * @param outlen the desired output length in bytes
     * @return the n-folded data of the specified length
     */

## Return Type and Data Filtering { #return-type-and-data-filtering }

Let's continue from the previous example. We wanted to **annotate the function with one type**, but we wanted to be able to return from the function something that actually includes **more data**.

    }

    /**
     * Get the context data
     *
     * @return encoded context data
     */
    public byte[] getData() {
        // Encode the context data
        byte[] data = new byte[20]; // 2 + 2 + 4 + 4 + 4 + 4

        int idx = 0;
        SMBUtil.writeInt2(transformCount, data, idx);
        idx += 2;
        SMBUtil.writeInt2(reserved1, data, idx);
        idx += 2;

    // Write just enough to not trip the threshold
    if (chunk1 > 0) {
      write(out, data, 0, chunk1, singleByte);
      assertTrue(ByteSource.wrap(data).slice(0, chunk1).contentEquals(source));
    }
    File file = out.getFile();
    assertThat(file).isNull();

    // Write data to go over the threshold
    if (chunk2 > 0) {
      write(out, data, chunk1, chunk2, singleByte);
      file = out.getFile();

            byte[] signature = mac.doFinal();

            // Place signature in data
            System.arraycopy(signature, 0, data, SIGNATURE_OFFSET, SIGNATURE_LENGTH);

            boolean result = digest.verify(data, 0, data.length, 0, msg);

            // FIXED: Should return true for valid signature (was previously expecting false)
            assertTrue(result, "Should return true for valid signature");

    void testGetSize() throws SMBProtocolDecodingException {
        // Prepare test data
        byte[] buffer = new byte[22];
        long expectedAllocationSize = 1024L;
        long expectedEndOfFile = 512L;
        int expectedNumberOfLinks = 3;
        boolean expectedDeletePending = true;
        boolean expectedDirectory = false;

        // Encode test data
        int offset = 0;

        @app.post("/example/")
        def example(item: Item = Body(example={"data": "Data in Body example"})):
            return item

    @app.post("/examples/")
    def examples(
        item: Item = Body(
            examples=[
                {"data": "Data in Body examples, example1"},
                {"data": "Data in Body examples, example2"},
            ],
        ),
    ):
        return item