# before the pattern "-py3-" in the wheel name.
pkg_name=$(echo "${pure_python_whl}" | awk -F'-py3-' '{print $1}')

# Save the current working directory and then switch to the output directory.
pushd "${TFCI_OUTPUT_DIR}"

# Unpack the wheel to get all the file contents. The pure python wheel we built
# above is tagged with "py3-none-any". We cannot change the tags by simply

Las pruebas:

## Fragmentos de código { #code-snippets }

//// tab | Prueba

Este es un fragmento de código: `foo`. Y este es otro fragmento de código: `bar`. Y otro más: `baz quux`.

////

Les tests :

## Extraits de code { #code-snippets }

//// tab | Test

Ceci est un extrait de code : `foo`. Et ceci est un autre extrait de code : `bar`. Et encore un autre : `baz quux`.

////

					rpc.UpdateMetacacheListing(ctx, *c)
				}
			}
		}()
		o.ID = ""
	}

	if contextCanceled(ctx) {
		return entries, ctx.Err()
	}
	// Do listing in-place.
	// Create output for our results.
	// Create filter for results.
	o.debugln("Raw List", o)
	filterCh := make(chan metaCacheEntry, o.Limit)
	listCtx, cancelList := context.WithCancel(ctx)

                        }
                        val outputPrefix = if (file.startsWith("/META-INF/versions")) {
                            // Java 9 multi-release JAR entry, we must keep it nested in the output
                            file.subpath(0, 3).toString()
                        } else {
                            ""
                        }

package provider

import (
	"encoding/json"
	"errors"
	"fmt"
	"net/http"
	"net/url"
	"path"
	"strings"
	"sync"
)

// Token - parses the output from IDP id_token.
type Token struct {
	AccessToken string `json:"access_token"`
	Expiry      int    `json:"expires_in"`
}

// KeycloakProvider implements Provider interface for KeyCloak Identity Provider.

	creator     func() error
	closer      func() error
	blockSize   int
	streamWg    sync.WaitGroup
	reuseBlocks bool
}

// newMetacacheWriter will create a serializer that will write objects in given order to the output.
// Provide a block size that affects latency. If 0 a default of 128KiB will be used.
// Block size can be up to 4MiB.
func newMetacacheWriter(out io.Writer, blockSize int) *metacacheWriter {
	if blockSize < 8<<10 {

* array (as in JSON array): array
* API key: API key (do not translate to "clave API")
* 100% test coverage: cobertura de tests del 100%
* back and forth: de un lado a otro
* I/O (as in "input and output"): I/O (do not translate to "E/S")
* Machine Learning: Machine Learning (do not translate to "Aprendizaje Automático")
* Deep Learning: Deep Learning (do not translate to "Aprendizaje Profundo")

                return 42;
              }
            }));
  }

  public void testNullOutputStream() throws Exception {
    // create a null output stream
    OutputStream nos = ByteStreams.nullOutputStream();
    // write to the output stream
    nos.write('n');
    String test = "Test string for NullOutputStream";
    byte[] bytes = test.getBytes(US_ASCII);
    nos.write(bytes);

            byte[] emptyFileId = new byte[16];
            assertDoesNotThrow(() -> new Smb2ReadRequest(mockConfig, emptyFileId, outputBuffer, 0));
        }

        @Test
        @DisplayName("Should accept null output buffer")
        void testConstructorWithNullOutputBuffer() {
            assertDoesNotThrow(() -> new Smb2ReadRequest(mockConfig, testFileId, null, 0));
        }

        @Test