Now that we have all the security flow, let's make the application actually secure, using <abbr title="JSON Web Tokens">JWT</abbr> tokens and secure password hashing.

This code is something you can actually use in your application, save the password hashes in your database, etc.

We are going to start from where we left in the previous chapter and increment it.

        offset += 4;
        SMBUtil.writeInt2(bytesPerSect, buffer, offset);
        offset += 2;

        // Decode
        int bytesDecoded = smbInfoAllocation.decode(buffer, 0, buffer.length);

        // Verify - actual implementation reads 20 bytes (4 + 4 + 4 + 4 + 4)
        // bytesPerSect is read as Int2 but advances by 4 bytes (padding)
        assertEquals(20, bytesDecoded);

        private SmbFile lastFile;
        private String lastPath;

        @Override
        public boolean accept(SmbFile file) throws SmbException {
            lastFile = file;
            // Actually interact with the file to verify the mock interaction
            if (file != null) {
                lastPath = file.getPath();
            }
            return true;
        }
    }

    @Nested

            // even before the arguments from the command line are parsed.  Any exception
            // that would happen here should cause the build to fail at a later stage
            // (when actually parsing the POM) and will lead to a better exception being
            // displayed to the user, so just bail out and return false.
        }
        return false;
    }

# ----------------------------------------------------------
#                                                      Mail
#                                                     ------
# Does it send mock mail? (true: no send actually, logging only)
mail.send.mock = false

# SMTP server settings for main: host:port
mail.smtp.server.main.host.and.port = localhost:25

# The prefix of subject to show test environment or not

			crypto.MetaIV:                          "HTexa=",
			crypto.MetaAlgorithm:                   "DAREv2-HMAC-SHA256",
			crypto.MetaSealedKeySSEC:               "IAA8PGAA==",
			ReservedMetadataPrefix + "actual-size": "594870264",
			"content-type":                         "application/octet-stream",
			"etag":                                 "166b1545b4c1535294ee0686678bea8c-2",
		},
		Parts: []ObjectPartInfo{
			{

## El orden importa { #order-matters }

Al crear *path operations*, puedes encontrarte en situaciones donde tienes un path fijo.

Como `/users/me`, imaginemos que es para obtener datos sobre el usuario actual.

Y luego también puedes tener un path `/users/{user_id}` para obtener datos sobre un usuario específico por algún ID de usuario.

        String accountName = (String) getField(obj, "accountName");
        String primaryDomain = (String) getField(obj, "primaryDomain");

        // The actual implementation keeps lowercase for guest when Unicode is not enabled
        assertEquals("guest", accountName);
        assertEquals("DOM", primaryDomain);

        byte[] lm = (byte[]) getField(obj, "lmHash");

        inputStream.reset();
    }

    /**
     * Skips over and discards n bytes of data from this input stream.
     *
     * @param n the number of bytes to be skipped
     * @return the actual number of bytes skipped
     * @throws IOException if an I/O error occurs
     */
    @Override
    public long skip(final long n) throws IOException {
        return inputStream.skip(n);
    }

    /**

# Gradle runtimes

Gradle is made up of the following processes that work together to "run the build":

- Gradle daemon. This is the process that actually runs the build. It hosts build logic and coordinates the lifecycle of the build. It is a long-running daemon process.
- CLI client. This is the `gradle` or `gradlew` command, and is responsible for locating, starting and interacting with the Gradle daemon, potentially downloading the Gradle distribution.