package cmerge_test

import (
	"fmt"
	"internal/coverage"
	"internal/coverage/cmerge"
	"testing"
)

func TestClash(t *testing.T) {
	m := &cmerge.Merger{}
	err := m.SetModeAndGranularity("mdf1.data", coverage.CtrModeSet, coverage.CtrGranularityPerBlock)
	if err != nil {
		t.Fatalf("unexpected clash: %v", err)
	}
	err = m.SetModeAndGranularity("mdf1.data", coverage.CtrModeSet, coverage.CtrGranularityPerBlock)
	if err != nil {

			s.Type = objabi.SCOVERAGE_COUNTER
		}
	}
	cm := coverage.ParseCounterMode(counterMode)
	if cm == coverage.CtrModeInvalid {
		base.Fatalf("bad setting %q for covermode in coveragecfg:",
			counterMode)
	}
	var cg coverage.CounterGranularity
	switch counterGran {
	case "perblock":
		cg = coverage.CtrGranularityPerBlock
	case "perfunc":
		cg = coverage.CtrGranularityPerFunc
	default:

                }

                return new Coverage(name, covered, missed)
            })
        }
    }

    void assertHasClassCoverage(String clazz, int covered=1) {
        def coverage = findClass(clazz)
        assert coverage
        assert coverage.covered == covered
    }

    /**
     * Verify that the argument was found and analyzed, but has a coverage rate of zero.
     * @param clazz
     */

      - name: Get coverage files
        uses: actions/download-artifact@v4
        with:
          pattern: coverage-*
          path: coverage
          merge-multiple: true
      - run: pip install coverage[toml]
      - run: ls -la coverage
      - run: coverage combine coverage
      - run: coverage report
      - run: coverage html --show-contexts --title "Coverage for ${{ github.sha }}"

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package cfile

import (
	"fmt"
	"internal/coverage"
	"internal/coverage/rtcov"
	"io"
	"sync/atomic"
	"unsafe"
)

// WriteMetaDir implements [runtime/coverage.WriteMetaDir].
func WriteMetaDir(dir string) error {
	if !finalHashComputed {
		return fmt.Errorf("error: no meta-data available (binary not built with -cover?)")

// meta data "blob" emitted by the compiler when coverage instrumentation
// is turned on.

import (
	"encoding/binary"
	"fmt"
	"internal/coverage"
	"internal/coverage/slicereader"
	"internal/coverage/stringtab"
	"io"
	"os"
)

// See comments in the encodecovmeta package for details on the format.

type CoverageMetaDataDecoder struct {
	r      *slicereader.Reader
	hdr    coverage.MetaSymbolHeader
	strtab *stringtab.Reader

WARNING: The Test Report Aggregation plugin does not currently work with the ``com.android.application`` plugin.

====
include::sample[dir="kotlin",files="code-coverage-report/build.gradle.kts[tag=**]"]
include::sample[dir="groovy",files="code-coverage-report/build.gradle[tag=**]"]
====

go test -coverprofile=cov.p -coverpkg=./... ./...
stdout '^ok\s+M/a\s+\S+\s+coverage: 50.0% of statements in ./...'
stdout '^ok\s+M/b\s+\S+\s+coverage: 60.0% of statements in ./...'
stdout '^ok\s+M/c\s+\S+\s+coverage: 30.0% of statements in ./...'
stdout '^\s*M/d\s+coverage: 0.0% of statements'
stdout '^\s*M/f\s+coverage: 0.0% of statements'

# Test just the test-only package ./e but with -coverpkg=./...

// license that can be found in the LICENSE file.

package test

import (
	"fmt"
	"internal/coverage"
	"internal/coverage/decodemeta"
	"internal/coverage/encodemeta"
	"internal/coverage/slicewriter"
	"io"
	"os"
	"path/filepath"
	"testing"
)

func cmpFuncDesc(want, got coverage.FuncDesc) string {
	swant := fmt.Sprintf("%+v", want)
	sgot := fmt.Sprintf("%+v", got)
	if swant == sgot {
		return ""

// rgb returns an rgb value for the specified coverage value
// between 0 (no coverage) and 10 (max coverage).
func rgb(n int) string {
	if n == 0 {
		return "rgb(192, 0, 0)" // Red
	}
	// Gradient from gray to green.
	r := 128 - 12*(n-1)
	g := 128 + 12*(n-1)
	b := 128 + 3*(n-1)
	return fmt.Sprintf("rgb(%v, %v, %v)", r, g, b)
}

// colors generates the CSS rules for coverage colors.
func colors() template.CSS {