// hence the calculation is made accordingly.
func totalByteLength(headerLength, payloadLength int) int {
	return 4 + 4 + 4 + headerLength + payloadLength + 4
}

func genMessage(header, payload []byte) []byte {
	headerLength := len(header)
	payloadLength := len(payload)
	totalLength := totalByteLength(headerLength, payloadLength)

	buf := new(bytes.Buffer)

            } catch (RepositoryMetadataReadException e) {
                if (getLogger().isDebugEnabled()) {
                    getLogger().warn(e.getMessage(), e);
                } else {
                    getLogger().warn(e.getMessage());
                }
                return setRepository;
            }

            if (repoMetadata.isSnapshot() && (previousMetadata != null)) {

            throw new TransferFailedException("Connection failed: " + e.getMessage(), e);
        } catch (AuthenticationException e) {
            throw new TransferFailedException("Authentication failed: " + e.getMessage(), e);
        } catch (AuthorizationException e) {
            throw new TransferFailedException("Authorization failed: " + e.getMessage(), e);
        } finally {

        try {
            getProject(f1);
            fail("Expected 'ProjectBuildingException' not thrown.");
        } catch (final ProjectBuildingException e) {
            assertNotNull(e.getMessage());
            assertThat(e.getMessage(), containsString("Version must be a constant"));
        }
    }

    /**
     * Tests whether local version range parent references are build correctly.
     *
     * @throws Exception

        then:
        def ex = thrown(IllegalStateException)
        1 * context.getProjectPath() >> Path.path('foo')
        ex.getMessage().contains('Dependency locking cannot be used for project')
        ex.getMessage().contains('foo')
    }

    def 'fails to read a legacy lockfile if root could not be determined'() {
        FileResolver resolver = Mock()

                            loc != null ? loc.getLineNumber() : -1,
                            loc != null ? loc.getColumnNumber() : -1,
                            e,
                            e.getMessage(),
                            BuilderProblem.Severity.WARNING));
                }
            }
        } catch (XmlReaderException e) {

                }
            }

            message = "The build could not read " + children.size() + " project" + (children.size() == 1 ? "" : "s");
        } else {
            message = getMessage(message, exception);
        }

        return new ExceptionSummary(exception, message, reference, children);
    }

    private ExceptionSummary handle(ProjectBuildingResult result) {

        given:
        platform.displayName >> '<unknown>'

        expect:
        def platformToolChain = toolChain.select(language, platform)
        !platformToolChain.available
        getMessage(platformToolChain) == "Don't know how to build for <unknown>."

        where:
        language << [NativeLanguage.ANY, NativeLanguage.CPP]
    }

    def "is unavailable when language is not known"() {

            pluginManager.setupPluginRealm(pluginDescriptor, session, null, null, null);
        } catch (Exception e) {
            throw new PluginManagerException(plugin, e.getMessage(), e);
        }

        ClassLoader oldClassLoader = Thread.currentThread().getContextClassLoader();
        try {
            Thread.currentThread().setContextClassLoader(pluginDescriptor.getClassRealm());

            return e;
        }

        SSLHandshakeException sslException = (SSLHandshakeException) e;
        String message;

        if (e.getMessage().contains("PKIX path building failed") || e.getMessage().contains("certificate_unknown")) {
            message = "Got SSL handshake exception during request. It might be caused by SSL misconfiguration";
        } else {
            message = String.format(