இது உலக நாடுகளின் ஒரு அகரமுதற் பட்டியலாகும். நீங்கள் நாடுகளை தலைநகரம்வாரியாகவோ, கண்டங்கள் வாரியாகவோ, மக்கள்தொகை வாரியாகவோ, பரப்பளவு வாரியாகவோ, மக்கள்தொகை அடர்த்தி வாரியாகவோ, நேர வலயம் வாரியாகவோ கூட உலவலாம்.

விக்கித் திட்டம் நாடுகள் திட்டமானது தமிழ் விக்கியில் காணப்படும் மற்றும் இனி வரவிருக்கும் நாடுகள் பற்றிய கட்டுரைகள் ஒரு சீர்தரத்துக்குள் கொண்டுவரும் நோக்கில் அமைந்தது.

மேலதிக மூலங்களுக்கு புவியியல் குறிப்புகளைப் பார்க்கவும்.
{| id="toc" border="0"
! :
அ ஆ இ ஈ உ ஊ எ ஏ ஐ ஒ ஓ க ச ட த ந ப ம ய ர ல வ ஹ ஸ ஜ
|}
<table border=1 cellpadding=1 cellspacing=0 style="float: right; border-collapse: collapse;">
நாடுவாரியான பட்டியல்

அ 
 
  (ஐக்கிய அமெரிக்க நாடுகள்)
 
 
 
 
 
 
 

 ஆ 
 
 
 
 
 

 இ 
 
 
 
 
 
 

 ஈ 
  
 

 உ 
  
  
  
 
  
 ஊ 

எ
 
 
 
 
 
 
 

 ஏ 

ஐ
 
 
 
 

 ஒ 
 ஒல்லாந்து நெதர்லாந்து பார்க்கவும்.

 ஓ 
 

 க 
 
 
 
 
 
 
  (முன்னர் ஸயர்) 
 
 
 
 
 
 
 
 
 
 
 2 
 
 
 
 
  
 
 
 
 
 

 ச 
 
 
 
 
 
 
 
 
 
 
 
 
 1 (தாய்வான்) 
  
 
 
 
  
 
 
 
 
 
 
 
 
 
 

 ட 
 ட்ரினிடாட்டும் டொபாகோவும் 
  
 டொங்கா 
 டொமினிக்கா 
 டொமினிகன் குடியரசு 
 டோகோ

 த 
  
 தாய்வான் (பார் சீனக் குடியரசு1) 
 தான்ஸானியா 
 தாஜிக்ஸ்தான் 
 திமோர் லெஸ்தே (பார் கிழக்குத் திமோர்) 
  
 துருக்மெனிஸ்தான் 
 துவாலு 
 துனீசியா 
 தென் கொரியா 
 தென்னாபிரிக்கா

 ந 
  
  
  
  
  
  
   
  
  2 
 

 ப 
  
 பர்மா (இப்பொழுது மியன்மார்) 
  
  
  (பார் மேற்குக் கரை)
  3 
 
 
 
  
 
  
  
  
  
  
 
  
  
  
 
  
  
 
 
 
  
  
  
   
  
 

 ம 
  
 6
 
  
  
  
  
  
  
  
  
 மேற்கு சமோவா(இப்பொழுது சமோவா)
 5 
 
 
  
  
 
  
  
 
 

 ய 
 யேமன்
 யப்பான்

 ர 
 ரஷ்யா 
 ருமேனியா 
 ருவாண்டா

 ல 
  
  
  
  
  
 லெய்செஸ்டீன்(Liechtenstein) 
  
  
 

 வ 
  
  
  4 (Holy See) 
  
  
 

 ஹ 
 ஹங்கேரி
 ஹைத்தி 
 ஹொண்டூராஸ்

 ஸ 
 ஸ்பெயின் 
 சிலவாக்கியா
 சிலவேனியா
 சாம்பியா
 ஸயர் (இப்பொழுது கொங்கோ ஜனநாயகக் குடியரசு) 
 ஸிம்பாப்வே

 ஜ 
 ஜமேக்கா 
 ஜிபூட்டி
 ஜெர்மனி 
 ஜோர்தான்
 ஜோர்ஜியா

குறிப்புகள் 
இங்கு பட்டியலிடப்பட்டுள்ள நாடுகளின் நிலைமை / இறைமை பற்றிய விபரங்கள்.

 1 சீனக் குடியரசு(தாய்வான்): Political status of Taiwan பார்க்கவும்.
 2 குக் தீவுகளும் நியூவும்: நியூசிலாந்துடனான ஒரு free கூட்டு (association); Niue Constitution Act 1974 (NZ) ஐயும் பார்க்கவும்.
 3 பலஸ்தீனம்: "பலத்தீன் நாடு" 1988 ஆம் ஆண்டு பிரகடனப்படுத்தப்பட்டுப் பல அரபு மற்றும் முஸ்லிம் நாடுகளால் அங்கீகரிக்கப்பட்டுள்ளது. proposals for a Palestinian state ஐயும் Palestinian territories ஐயும் பார்க்கவும். காஸா Strip, மேற்குக் கரை, இஸ்ரேல் என்பவற்றுக்குப்பலஸ்தீனப் பிரதேசம் தொடர்பில் கட்டுரைகள் உள்ளன.
 4 வத்திக்கான்: Holy See பார்க்கவும்.
 5 மேற்கு சஹாரா: Politics of Western Sahara பார்க்கவும்.
 6 மசிடோனியக் குடியரசு: "முன்னாள் யூகோஸ்லாவியாவின் மசிடோனியக் குடியரசாக" அனைத்துலக அளவில் பரிச்சயமானது. **http://www.un.org/documents/ga/res/47/a47r225.htm ஐப் பார்க்கவும்.

தொடர்புள்ள தலைப்புகள் 
 ஐ.எசு.ஓ 3166-1
 இறைமையுள்ள நாடு
 உலக நாடுகள் பட்டியல் (கண்டங்கள் வாரியாக)
 பன்னாட்டுத் தலைநகரங்களின் பட்டியல்
 உலக நாடுகளின் மரபுச் சின்னங்கள்
 ஏற்கப்படாத நாடுகள்
 சார்பு மண்டலம்

 
நாடுகள் தொடர்பான பட்டியல்கள்

nds:Land#Länner
sv:Världsgeografi#Lista över länder

Maria, a Judia ou Maria, a Profetisa, é uma antiga filósofa grega e famosa alquimista que viveu no Egipto por volta do ano 273 a.C..

Alguns a situam na época de Aristóteles (384–322 a.C.), uma vez que a concepção aristotélica dos quatro elementos formadores do mundo (o fogo, o ar, a terra e a água) condiz bastante com as idéias alquimistas de Maria, como o axioma de Maria: «o Um torna-se Dois, o Dois torna-se Três, e do terceiro nasce o Um como Quatro». Segundo Aristóteles, o enxofre era considerado a expressão do elemento fogo, e Maria o tomou como base para os principais processos que estudou. Ela menciona o enxofre em frases sempre misteriosas, como «uma pedra que não é pedra» e «tão comum que ninguém a consegue identificar». Maria conta que Deus lhe revelou uma maneira de calcinar cobre com enxofre para produzir ouro. Esse enxofre era obtido do disulfeto de arsênico, que é achado em minas de ouro. Talvez tenha sido essa a origem da lenda da transformação de metais menos nobres em ouro.

Dentre as invenções de Maria estão o kerotakis, uma espécie de barril fechado e o banho de vapor: para um aquecimento lento e gradual dos experimentos, em vez de manipular as substâncias diretamente no fogo, ela descobriu que era possível controlar melhor a temperatura se fosse por meio da água - que até hoje chamamos de banho-maria. Para além disso dois equipamentos de destilação (alambique), com duas ou três saídas para destilados — o dibikos e o tribikos — e um aparelho para sublimação, sendo-lhe ainda atribuída a descoberta do ácido clorídrico. A maior parte das suas escrituras foram conservadas por Zósimo de Panópolis (300 d.C.).

Fontes
Não existem elementos concretos sobre o tempo e lugar de sua vida. Ela é mencionada pelos primeiros alquimistas da história, sempre como uma autoridade e respeito extremo. Os alquimistas do passado acreditava que ela era Miriã, irmã de Moisés e Arão, o profeta, mas há evidências que apoiam que esta reivindicação é falsa.

A menção mais concreta de Maria, a Judia no contexto da alquimia é por Zósimo de Panópolis, que escreveu no século IV os livros alquimistas mais antigos conhecidos . Zósimo descreve vários de seus experimentos e instrumentos. Em seus escritos, Maria é quase sempre citada como tendo vivido no passado e citou-a como uma das "sábias".

Jorge Sincelo, um cronista bizantino do século VIII, apresenta Maria como uma professora de Demócrito, a quem ela conheceu em Mênfis, Egito na época de Péricles. No século X Kitab al-Fihrist de Ibn al-Nadim cita-a como uma das cinqüenta e duas mais famosas alquimistas, sabendo da preparação do caput mortuum. O filósofo romano Morieno chamou de "Maria, a profetisa" e os árabes a conheciam como a "Filha de Platão", um nome que em ocidentais textos alquímicos foi reservada para o enxofre branco.
No livro de Alexandre (2 ª parte) do poeta persa Nizami, Maria, uma princesa síria, visita o Tribunal de Alexandre, o Grande, e aprende a partir de Aristóteles (384 aC - 322 aC), entre outras coisas, a arte de fazer ouro.

Trabalhos

Escrituras

Sabe-se que Maria escreveu vários textos sobre alquimia. Embora nenhum de seus escritos ter sobrevivido em sua forma original, os seus ensinamentos foram amplamente citados por autores posteriores herméticos. Seu trabalho principal sobrevivente é um extrato feito por um anônimo filósofo cristão, chamado O Diálogo de Maria e Aros sobre o Magistério de Hermes, em que são descritas e nomeadas operações que seriam mais tarde a base da Alquimia, leucose (branqueamento) e xanthosis (amarelecimento). Uma foi feita por moagem e do outro por calcinação. Este trabalho descreve pela primeira vez um sal de ácido e outros ácidos que podem ser identificados com ácido acético. Há também várias receitas para fazer ouro, até mesmo de vegetais de raiz como o Mandragora.
Vários enigmáticos preceitos alquímicos têm sido atribuídas a Maria. Ela supostamente disse da união dos opostos:

Esta outra vem do Axiom de Maria

Invenções
Maria era uma trabalhadora respeitada, que inventou aparelhos complicados de laboratório para a destilação e sublimação de materiais químicos. Maria disse ter descoberto o ácido clorídrico, embora isso não seja aceito pela maioria dos textos científicos  .
Também são atribuídas a ela a invenção dos aparelhos de alquimia conhecidos como tribikos, kerotakis e o banho-maria.

Tribikos
Maria aperfeiçoou a câmara de destilação de três braços. O tribikos era uma espécie de alambique com três braços que foi utilizado para obter as substâncias purificadas por destilação. Ninguém sabe ao certo se Maria, a Judia foi sua inventora, mas Zósimo credita que a primeira descrição deste instrumento para ela. Em seus escritos (citado por Zósimo), ela recomenda que o cobre ou bronze utilizados para criar os tubos sejam da espessura de uma frigideira, e a junção entre estes tubos deve ainda ser selada com farinha de colar na cabeça

Kerotakis
O kerotakis é a invenção mais importante de Maria, a Judia, um dispositivo usado para aquecer substâncias utilizadas na alquimia e recolher os vapores. É um recipiente hermético com uma folha de cobre suspensa no topo. Quando funciona corretamente, todas as articulações são no vácuo apertado. O uso de tais recipientes fechados nas artes herméticas levaram ao termo "hermeticamente fechada". Maria e seus colegas acreditavam que a reação que se dá no kerotakis era uma reconstituição do processo de formação do ouro que acontecia nas entranhas da terra. Mais tarde, este instrumento foi modificado pelo alemão Franz von Soxhlet em 1879 para criar o extrator que leva seu nome, Soxhlet.

Banho-maria

Ver também 
 Mulheres na ciência
 Alquimia
 Judaísmo
 Moisés
 Miriã
 Banho-maria

Bibliografía 
 GREENBERG, Arthur, Chemical History Tour, Picturing Chemistry from Alchemy to Modern Molecular Science. Wiley-Interscience 2000, ISBN 0-471-35408-2
 STROHMEIER, Renate, Lexikon der Naturwissenschaftlerinnen und naturkundigen Frauen Europas. Von der Antike bis zum 20. Jahrhundert. Verlag Harri Deutsch, 1998, ISBN 3-8171-1567-9

Ligações externas

Inventoras
Alquimistas
Inventores
Filósofos da Grécia Antiga
Mulheres da Grécia Antiga
Filósofas
Mulheres na ciência
Gregos do século III a.C.
Mulheres do século III a.C.
!Mais Teoria da História na Wiki (Mulheres)
!Mais Teoria da História na Wiki (Wikiconcurso de edição)

'use strict';

const _ = require('lodash');
const fs = require('fs-extra');
const glob = require('glob');
const path = require('path');

const minify = require('../common/minify.js');

/*----------------------------------------------------------------------------*/

/**
 * Creates a [fs.copy](https://github.com/jprichardson/node-fs-extra#copy)
 * function with `srcPath` and `destPath` partially applied.
 *
 * @memberOf file
 * @param {string} srcPath The path of the file to copy.
 * @param {string} destPath The path to copy the file to.
 * @returns {Function} Returns the partially applied function.
 */
function copy(srcPath, destPath) {
  return _.partial(fs.copy, srcPath, destPath);
}

/**
 * Creates an object of base name and compiled template pairs that match `pattern`.
 *
 * @memberOf file
 * @param {string} pattern The glob pattern to be match.
 * @returns {Object} Returns the object of compiled templates.
 */
function globTemplate(pattern) {
  return _.transform(glob.sync(pattern), (result, filePath) => {
    const key = path.basename(filePath, path.extname(filePath));
    result[key] = _.template(fs.readFileSync(filePath, 'utf8'));
  }, {});
}

/**
 * Creates a `minify` function with `srcPath` and `destPath` partially applied.
 *
 * @memberOf file
 * @param {string} srcPath The path of the file to minify.
 * @param {string} destPath The path to write the file to.
 * @returns {Function} Returns the partially applied function.
 */
function min(srcPath, destPath) {
  return _.partial(minify, srcPath, destPath);
}

/**
 * Creates a [fs.writeFile](https://nodejs.org/api/fs.html#fs_fs_writefile_file_data_options_callback)
 * function with `filePath` and `data` partially applied.
 *
 * @memberOf file
 * @param {string} destPath The path to write the file to.
 * @param {string} data The data to write to the file.
 * @returns {Function} Returns the partially applied function.
 */
function write(destPath, data) {
  return _.partial(fs.writeFile, destPath, data);
}

/*----------------------------------------------------------------------------*/

module.exports = {
  copy,
  globTemplate,
  min,
  write
};

Berthold Konrad Hermann Albert Speer (Mannheim, 19 maart 1905 – Londen, 1 september 1981) was een Duits architect en stedenbouwkundige. Tijdens de naziheerschappij over Duitsland (1933-1945) was hij vanaf 1937 rijksarchitect en vanaf 1942 rijksminister van Bewapening en Munitie. Door zijn vriendschap met Adolf Hitler en zijn ministerschap gold hij als een van de machtigste mannen van het Derde Rijk. Na de oorlog werd Speer in Neurenberg veroordeeld tot twintig jaar gevangenisstraf.

Voor 1933 
Het gezin waarin Speer werd geboren, was wat ze in het Duits noemen grossbürgerlich; in Nederlandse termen gegoede burgerij of bourgeoisie. Zijn vader en grootvader waren beiden architecten. Om financiële redenen studeerde Speer aanvankelijk in Karlsruhe. Van de lente van 1924 tot de zomer van 1925 zette hij zijn studie vervolgens voort aan de technische hogeschool van München. In de herfst van 1925 verhuisde hij naar Berlijn en probeerde hij vergeefs aan de Technische Hogeschool in Berlijn-Charlottenburg in het seminarie van Hans Poelzig toegelaten te worden. In 1926 ontving Heinrich Tessenow, een architect van de behoudende school met een zeer bescheiden en niet megalomane stijl, een leerstoel. Speer werd in dat jaar een van zijn studenten. Na zijn diploma te hebben behaald in 1927 bleef Speer nog meerdere jaren, als Tessenows assistent, aan de hogeschool verbonden.

Architect in dienst van Hitler 

Speer was niet bijzonder geïnteresseerd in politiek. Hij werd echter reeds in januari 1931 lid van de NSDAP nadat hij in december 1930 een toespraak van Adolf Hitler had bijgewoond in de Berlijnse Hasenheide. Deze toespraak had een diepe indruk gemaakt op Speer. Zelf schreef hij dat hij een maand had getwijfeld, maar dat hij uiteindelijk toch besloten had om lid te worden, omdat Hitler helemaal niet stereotiep was overgekomen in de toespraak. Het was een zeer rustige toespraak waarin het woord 'Jood' niet één keer was gevallen.

In 1932 verliet Speer Berlijn en ging terug naar Mannheim. Hij vestigde zich daar als architect, maar hij kreeg geen opdrachten. In 1934 werd hem gevraagd de meivieringen van de partij vorm te geven. Speers originele idee was om rond het veld in Neurenberg waar de parades werden afgenomen een reeks zoeklichten recht omhoog te laten schijnen. Hierdoor ontstond een mooi lichtspel wat een koepel van licht boven het paradeveld veroorzaakte. Hitler was hierover zeer enthousiast en zo werd Speer Hitlers huisarchitect.

Toen Hitlers toenmalige Hofarchitekt, de uit München afkomstige Paul Ludwig Troost, in 1934 overleed, nam Speer diens taken over, waarmee hij zijn formele leidinggevende Rudolf Hess feitelijk snel overschaduwde in macht en ook in aanzien bij Hitler. Speer ontwierp talrijke gebouwen in klassieke stijl, die als doel hadden de pracht en de macht van het Derde Rijk te tonen en te onderstrepen. In het Deutsche Arbeitsfront (DAF) leidde hij de afdeling Schönheit der Arbeit. Verder werd hij de chef van de onderafdeling van de Rijkspropagandaleiding en verantwoordelijk voor de stedenbouw in de staf van Rudolf Hess.

Voor de wereldtentoonstelling van 1937 in Parijs ontwierp hij het Duitse paviljoen. Het hoofdbestanddeel bestond uit een enorme toren in classicistische stijl met een grote Duitse adelaar erop. Speer kreeg er de Grand Prix met een gouden medaille voor.

De belangrijkste gebouwen en de aanleg van urbane ruimtes voor het Derde Rijk ontwierp Speer echter in Berlijn en Nürnberg. Berlijn als rijkshoofdstad en bestuurscentrum lag voor de hand. In Nürnberg werden voor de machtsovername al diverse zogenaamde partijdagen gehouden, propagandistische massabijeenkomsten georganiseerd door de NSDAP, om het nationaalsocialisme te etaleren aan de Duitse kiezers. Deze Beierse stad lag niet ver van München, de bakermat van de nazipartij, en was daarbij goed bereikbaar via een uitgebreid verkeersnetwerk en bezat als toeristische trekpleister voldoende hotels om veel volk onderdak te bieden. Nürnberg kozen de nazi's ook meer symbolisch als zijnde een belangrijke vroegere rijksstad van het Heilige Roomse Rijk, de plek waar men destijds de rituele symbolen van de keizerlijke macht bewaarde zoals de rijksappel, de scepter en de kroon. De nazi's zetten met de keuze van Nürnberg een eeuwenoude traditie van jaarmarkten, machtige keizers en kastelen voort door daar de nazipartijdagen te laten plaatsvinden. Na de verkiezingsoverwinning in 1933 ging het terrein van de partijdagen grondig op de schop en werd in opdracht van Hitler flink uitgebreid.

Berlijn

In 1937 werd hij benoemd tot regeringscommissaris voor de bouw in de staf van de Führer en inspecteur-generaal voor de bouwnijverheid in Berlijn. Zijn ontwerpen waren naar de smaak van Hitler die hield van gebouwen in een neoclassicistische stijl met een minimalistische uitstraling maar dan vergroot tot buitensporige afmetingen. Voor de spaarzame aankleding wilde Hitler het liefst de klassieke Arische beelden gebruiken van de hand van de door Hitler bewonderde Arno Breker. Vooral voor Berlijn had Hitler grootse plannen. Deze stad zou na de Endsieg herdoopt worden in Germania (overigens is Speer de enige bron die dit beweerde). Met talloze statige bouwwerken en brede boulevards wilde Hitler aan zijn hoofdstad een enorme grandeur geven. Hitlers en Speers megalomane motto was: 'hoe groter hoe beter'. Speer ordonneerde stabiliteitstesten in de moerassige grond van Berlijn om na te gaan of deze het enorme gewicht van de geplande gebouwen kon dragen. Daartoe bouwde de firma Dyckerhoff & Widmann AG in 1941 tegen de prijs van 400 000 Reichsmark aan de rand van Berlijn het Schwerbelastungskörper. Het betrof een betonnen 12 360 ton wegende cilinder met een diameter van 21 m. De nog intact zijnde kolos veroorzaakte volgens Speers metingen een verzakking van 19 cm. De Berlijnse ondergrond was bijgevolg geschikt voor het bouwen van dergelijke grootschalige bouwwerken. Tevens werd een begin gemaakt met het aanleggen van de weids opgezette boulevards. In 1938 en 1939 werd in recordtijd de bouw van de nieuwe Rijkskanselarij aan de Wilhelmstrasse en de Voßstraße voltooid. Speer toonde zich hier al als een goede bouworganisator. Het bouwwerk met gigantische afmetingen (het geheel mat 200 ha) was voor Hitler een representatieve plaats om de buitenlandse gasten en diplomaten te ontvangen. Zij moesten op deze wijze onder de indruk raken van de grootsheid van het Duitse Rijk. Het merkwaardigste onderdeel van het geheel betrof een lange rechte galerij van 146 m lengte, twee maal zo lang als de spiegelzaal in Versailles van 73 meter, met een spiegelgladde vloer die leidde naar de persoonlijke ontvangstruimten van Hitler; deze "straat" werd "der lange Marsch der Diplomaten" genoemd. Sommigen maakten de opmerking dat de gladde vloer eigenlijk wel gevaarlijk was om op te lopen. Hitler wimpelde deze bezwaren weg met de woorden: “Diplomaten zijn wel gewend om zich op glad ijs te begeven”. Door het uitbreken van de oorlog moesten verdere plannen echter opgeschort worden. Gereed kwamen wel het vliegveld Tempelhof dat nog steeds een van de grootste luchthavengebouwen ter wereld heeft. Ook het nog steeds gebruikte Olympisch Stadion van 1936 was een onderdeel van de herbouw van Berlijn. Hitlers nieuwe kanselarij werd tijdens de eindstrijd in 1945 zwaar beschadigd en kort na de oorlog afgebroken.

Nürnberg

In deze vroegere Rijksstad, in het Nederlands wordt de stad meestal Neurenberg genoemd, ontwierp Speer vanaf 1934 een aantal gebouwen op het Reichsparteitagsgelände (de terreinen van de rijkspartijdagen) vertrekkende van het masterplan van architect-urbanist Paul Ludwig Troost. Troost kreeg van de partij opdracht om een recreatiegebied aan de stadsrand om te vormen tot een geschikte locatie voor een massa-evenement het zogenoemde Reichtsparteigelände, een gebied van 11 km². Men verplaatste daartoe de dierentuin en de vuurtoren brak men af. Men voorzag in een Große Straße van 1,5 km lengte en 50 m breed die visueel aansloot op de middeleeuwse keizerlijke burcht van Nürnberg. Gevangenen van het concentratiekamp Flossenbürg en Mauthausen kapten het graniet voor de 6 000 tegels waarover de soldaten zouden marcheren. Langs deze lange straatas plande men de Luitpoldarena, het Zeppelinveld, het Deutsches Stadion, een Hitlerjugendstadion, een Marsveld en twee treinstations. Slechts het Zeppelinveld met dito tribune naar een ontwerp van Speer werd afgewerkt. De kosten van de oorlogsindustrie beletten de verdere uitbouw van al deze megalomane plannen. Voor de tribune met een lengte van 360 m stond het antieke kleinschaligere Pergamonaltaar model. 320 000 toeschouwers konden de parades op het Zeppelinfeld volgen. Bij nacht schenen 250 grote spots de lucht in als een van ver te ziene lichtkathedraal. Nu is de plek herschapen tot een ruïne en op eigen risico te betreden. Via Google Earth kan men inzoomen op het Zeppelinveld en krijgt men een beeld van de huidige vervallen toestand.

Op deze plek filmde Leni Riefenstahl Hitlers propagandafilm Triumph des Willens over de aldaar gehouden Rijkspartijdag van 5 september 1934. Neurenberg is ook bekend van de Rassenwetten van Neurenberg en het ontnemen van burgerrechten van Joden. In deze stad vonden ook de naoorlogse processen van Neurenberg plaats. Door misleiding van het tribunaal wist Speer aan de doodstraf te ontkomen.

Speer als organisator en minister van bewapening vanaf 1942

Toen Hitler later meer en meer door de oorlog werd opgeslokt, verminderde zijn aandacht voor Speer maar hij verloor Speer omwille van zijn goede managerskwaliteiten niet echt uit het oog. Op 8 februari 1942 werd Speer, ondanks (of misschien wel dankzij) zijn vrij geringe politieke aspiraties, door Hitler benoemd als opvolger van de bij een vliegtuigongeluk omgekomen rijksminister voor Bewapening en Munitie, Fritz Todt. Speer gebruikte al zijn organisatietalent, reorganiseerde de productie van wapens en munitie.

Het Endspiel

Hitlers laatste bevelen aan Speer 
In de laatste weken van de oorlog weigerde hij Hitlers bizarre bevelen nog langer uit te voeren. Hitler wist dat de oorlog verloren was en wilde het Duitse volk, dat in zijn ogen in zijn missie gefaald had, met hem mee de afgrond in sleuren in een soort Götterdämmerung met het Nero-bevel. Dit moest bereikt worden door het vernietigen van de nog overgebleven, vitale delen van Duitsland en de bezette gebieden: de tactiek van de verschroeide aarde. Speer dacht al aan het overleven van de bevolking en de wederopbouw van Duitsland na de oorlog en gaf Hitlers bevelen niet meer door aan de afdeling die voor de uitvoering moest zorgen. Een eerder voorbeeld was Hitlers bevel in 1944 om Parijs te vernietigen toen de geallieerden de stad naderden. Doordat de Duitse commandant van Parijs (luitenant-generaal Dietrich von Choltitz) hier niet aan meewerkte en ook door de zeer snelle omsingeling en verovering van Parijs werd dit verhinderd.

Arrestatie 

Op 24 april 1945 vloog Speer, die Berlijn al was ontvlucht, speciaal terug om in de bunker onder de Rijkskanselarij afscheid van zijn Führer te kunnen nemen. Hitler pleegde uiteindelijk op 30 april zelfmoord, samen met Eva Braun die even tevoren met hem getrouwd was, en liet zijn instortende "Derde Rijk" in totale chaos achter. Op 23 mei 1945 werd Speer samen met Karl Dönitz (door Hitler per testament aangewezen als zijn opvolger) gearresteerd in Flensburg, van waaruit verschillende nazileiders, die niet in Berlijn waren gebleven, tevergeefs vredesonderhandelingen met de geallieerden trachtten te voeren.

Proces van Neurenberg en gevangenschap 
Op 1 oktober 1946 werd Speer op het Proces van Neurenberg veroordeeld tot twintig jaar gevangenisstraf, vooral vanwege het feit dat onder zijn leiding één miljoen van de in totaal zes miljoen dwangarbeiders uit de bezette gebieden tijdens de oorlogsjaren in de wapenindustrie te werk waren gesteld. Van alle veroordeelde nazikopstukken was hij de enige die zich "verantwoordelijk" verklaarde voor de misdrijven van de nazistaat. Desondanks pleitte hij niet schuldig met als argument dat hij nooit persoonlijk opdrachten ondertekend had om gevangenen te deporteren. Speer schoof zijn volledige schuld af op de Minister van Arbeid, Fritz Sauckel die wel werd opgehangen. Zijn straf zat hij grotendeels uit in de Spandaugevangenis in Berlijn. Op 1 oktober 1966 kwam hij vrij.

Speer als de “nette nazi” 
Speer heeft tijdens het proces in Neurenberg als enige top-nazi bekend medeverantwoordelijk te zijn aan de misdaden die tijdens het Derde Rijk zijn begaan. Dit medeschuldig zijn werd door hemzelf echter weer snel gebagatelliseerd: hij schilderde zichzelf af als iemand die verblind was door Hitlers megalomane dromen. Vooral de mogelijkheid om zijn gigantische architectonische ontwerpen, met behulp van Hitlers steun, onbegrensd te kunnen verwezenlijken had Speer, naïef als hij toen volgens zichzelf was, over de streep getrokken. Met deze zienswijze suggereerde Speer dat zijn medewerking aan het regime toch enigszins buiten zijn schuld om was gebeurd: hij wist niet beter. Van de gruwelijke toestanden in de vernietigingskampen en de Jodenvervolging had Speer (naar eigen zeggen) sowieso keine Ahnung (geen weet).

Verder schreef hij, om zich te verdedigen tijdens het Neurenberg-proces, nog enkele "goede" maatregelen op zijn naam; zo verklaarde hij bij het zien van de slaapplaatsen van de dwangarbeiders in de steenhouwerijen en fabrieken van V2-raketten voor betere verblijfplaatsen te hebben gezorgd.

Na 'Spandau' en Speers overlijden 
Speer woonde na zijn vrijlating in de villa in Heidelberg die zijn vader in 1905 had laten bouwen. Hij trad daarna niet echt meer in de openbaarheid, op een enkel interview na, en besteedde zijn tijd aan het uitwerken van zijn aantekeningen en het publiceren ervan in verscheidene boeken. Door de inkomsten van zijn boeken en, zoals later bleek, ook door de heimelijke verkoop van tijdens de oorlog geroofde schilderijen kon Speer tot zijn dood een welgesteld leven leiden. In 1981, tijdens een bezoek aan Londen, overleed Speer vrij onverwacht aan een herseninfarct.

Nalatenschap en het einde van de mythe 
Speer liet tekeningen en een hoeveelheid dagboekaantekeningen na, die uit de gevangenis waren gesmokkeld. Deze werden in 1969 in boekvorm uitgegeven onder de titel Spandauer Tagebücher (later vertaald in het Engels onder de titel Spandau – the secret diaries). Zijn levensverhaal vertelt hij in Erinnerungen (Herinneringen). Ook over de rol van de SS schreef hij een boek: Der Sklavenstaat: Meine Auseinandersetzungen mit der SS. Tot slot is ook het boek Technik und Macht min of meer van zijn hand, namelijk Speers woorden, vastgelegd door Adelbert Reif.

Niet lang voor Speers onverwachte dood kwamen Duitse onderzoekers op het spoor van Speers werkelijke verantwoordelijkheid voor oorlogsmisdrijven. Speers vroegere medewerker Wolters was een fanatiek nazi gebleven en was zo verontwaardigd over Speers "verraad" van Hitler dat hij op zijn beurt onthullingen deed over Speer. Zo was het Speer die regelde dat tijdens de voorbereidingen voor de aanleg van de brede boulevards in Berlijn de Duitse bewoners van 23 765 onteigende woningen de woningen van Joden kregen toegewezen.<ref> Joseph Pearce, De doodsteek voor de 'goede nazi''', in: De Morgen, 26 september 2018. </ref> De Joodse bewoners werden op transport gezet naar de concentratiekampen. Albert Speer heeft zijn ontmaskering niet meer meegemaakt.

Onderzoek dat na de dood van Speer door Matthias Schmidt werd gepubliceerd, toonde aan dat Speer een zorgvuldig web van misleiding rond zijn werkelijke aandeel in de oorlogsmisdaden had geweven. Nauwkeurig historisch onderzoek van de Duitse historicus Magnus Brechtken ontkracht systematisch de door Speer geschapen mythe van Hitlers onwetende architect. Speer stelde onder meer niet aanwezig te zijn geweest bij de beruchte rede in Posen waarin Heinrich Himmler de nazileiders betrok bij de massamoord op de Joden. Himmler sprak op de geluidsopname daarentegen rechtstreeks tot Speer, dat wil zeggen, alsof Speer aanwezig was. Ook een document waarop materiaal voor de bouw van crematieovens en lijkenkelders in een concentratiekamp werd vrijgegeven met Speers handtekening van goedkeuring erop was voor Speer zeer belastend. In overleg met SS leider Heinrich Himmler besprak en leidde Speer als Generalbauinspektor de uitbreiding van het concentratiekamp Auschwitz. De kampen Sachsenhausen en Mauthausen ontstonden op aansturen van Speer om slavenarbeiders te leveren voor de ontginning van graniet, nodig voor Speers monumentale nazibouwwerken.

Speer heeft zijn medeplichtige Rudolf Wolters na de oorlog opdracht gegeven om belastende documenten te vernietigen. In de memoires liegt Speer over zijn bezigheden vlak voor de val van het Derde Rijk. Speer heeft een kostbare collectie romantische schilderijen, gestolen of afgeperst uit Joods bezit, verborgen. Na zijn vrijlating heeft hij de schilderijen voorzichtig en anoniem verkocht. De contant uitbetaalde opbrengst werd weggesluisd, waarschijnlijk naar zijn jonge maîtresse. De kunstwerken brachten een miljoen mark op. De opbrengst van de speculatie met een van de Joodse bankierserfgename Marie-Anne von Goldschmidt-Rothschild afgeperst stuk kostbare bouwgrond aan de oever van Schwanenwerder bij Berlijn moest Speer restitueren. Dat heeft hij ondanks een veroordeling nooit gedaan.

Gesprekken met Gitta Sereny leidden tot een boek van haar hand. Ze portretteerde Speer als een man die niet met zichzelf in het reine kon komen.

 Perspectief voor Speers architectuur 

Speer bedacht het Ruinenwert-principe. Dit hield in dat de ontwerper een gebouw zo moest vormgeven dat het ook als ruïne mooi zou ogen. De aftakeling van Speers gebouwen startte vlugger dan voorzien. De tribune van het Zeppelinveld van het Reichsparteigelände in Nürnberg brokkelde af vanaf de jaren zestig van de twintigste eeuw. Het stadsbestuur moest daartoe in 1967 een deel van de bouwvallige zuilengalerij afbreken. De tienduizenden toeristen die de gebouwen jaarlijks bezoeken maken nu hun selfies op eigen risico.Het grootschalige karakter van Speers bouwwerken en de prominente aanwezigheid ervan vooral in Nürnberg, plaatsen de Duitsers voor een dilemma hoe om te gaan met dit beladen erfgoed dat voortdurend herinnert aan de naziperiode. Het Neurenbergse stadsbestuur is vastberaden (2016) om het patrimonium ondanks de oplopende kosten in stand te houden en in te richten als plek van educatie en herinnering. Daartoe bouwde men in 2001 al een Dokumentationszentrum Reichsparteitagsgelände aan de noordelijk gelegen kop van het congrescentrum dat in 1935 gebouwd werd door architect Ludwig Ruff op het terrein. Aldaar ingerichte tentoonstellingen geven een beeld van de Ursachen, Zusammenhängen und Folgen der nationalsozialistischen Gewaltherrschaft. Besluit 
Nauwkeurig en uitvoerig bronnenonderzoek leidt tot de conclusie dat Speer tijdens het twaalf jaar (1933-1945) durend nazi-bewind twee doelen nastreefde: de nationaalsocialistische leer helpen uitvoeren en zichzelf verrijken. Tijdens de Neurenbergse processen en nadien stelde Speer alles in het werk om dit te verdoezelen en zichzelf neer te zetten als een "nette onwetende technocraat" die slechts voor het regime burgerlijke bouwwerken bedacht en uitvoerde. Daarbij kreeg hij uitgebreide hulp van journalist/historicus Joachim Fest en betrokken partij uitgeverij Siedler. De Duitse historicus Magnus Brechtken, directeur van het Institut für Zeitgeschichte in München, deed in dit verband een oproep om memoires, gedenkboeken en interviews nooit meer aan te wenden bij geschiedschrijving. Zij vormen in het slechtste geval een slinks samenstel van afleidingstrucs, retorische rookgordijnen en onversneden leugens. Een alarmbel in tijden van alom aanwezig nepnieuws.

 Wetenswaardig 
Albert Speer had zes kinderen. Een van zijn zonen, Albert Speer jr. (1934-2017), was eveneens een bekend architect en stadsplanner en ontwerper van voetbalstadions in Qatar voor het WK van 2022.

 Speers publicaties Die neue Reichskanzlei, 1940. Een propagandaboek over de nieuwe Rijkskanselarij die hij voor Hitler gebouwd heeft.Neue deutsche Baukunst, 1941.Erinnerungen, 1969. Een boek dat is samengesteld uit de verschillende notities op onder meer wc-papier die Speer gemaakt heeft tijdens zijn gevangenisperiode in Spandau.Die Spandauer Tagebücher, 1975. Dagboek van Speers gevangenistijd.Der Sklavenstaat. Meine Auseinandersetzungen mit der SS, 1981. Nederlandse vertaling: De slavenstaat. Himmlers SS: de multinational van het Derde Rijk, Elsevier, 1981. Over Speers ervaringen met en zijn verhouding tot Himmlers SS.Alles was ich weiß, 1999. Postume getuigenis van Speer.

 Literatuur 
 Magnus Brechtken, Albert Speer. Eine deutsche Karriere, 2017. (Nederlandse vertaling door Hans E. van Riemsdijk: Albert Speer. Een Duitse carrière, 2018)
 Heinrich Breloer: Unterwegs zur Familie Speer Joachim Fest: Die unbeantwortbaren Fragen. Notizen über Gespräche mit Albert Speer zwischen Ende 1966 und 1981 Interviews met Speer. (vertaling Gerda Meijerink, 2006, Onbeantwoordbare vragen, De Bezige Bij, 256 blz.)
 Joachim Fest: Speer, architect van Hitler, Aula, Amsterdam, 2004, vertaald uit het Duits.
 Joachim Fest: Speer, Eine biographie, Berlin 1999, uitgever Alexander Fest Verlag in Berlijn. .
 Lars Olof Larsson: Albert Speer, Le plan de Berlin, 1937-1943, Brussel, Archives d'Architecture Moderne, 1983.
 Maarten Mahieu, Op de ruïnes van het Derde Rijk. Overblijfselen van de rijkspartijdagen in Neurenberg, in: Eos. Geschiedenis nr 1, najaar 2016.
 Margret Nissen: Sind Sie die Tochter Speer? Matthias Schmidt: Albert Speer, das Ende eines Mythos. De onthulling van achtergehouden documenten over Speers daden in Berlijn en zijn woningpolitiek aldaar, 1982.
 Heinrich Schwendemann: Albert Speer. Architekt des Todes. Speer als de organisator van Duitslands oorlogsindustrie.
 Gitta Sereny: Das Ringen mit der Wahrheit (1995). Vertaald uit het Engels: Albert Speer - His struggle for truth.
 Ulrich Schlie: Die Kransberg-Protokolle 1945 Dan van der Vat: Der gute Nazi. Analyse van Speer als Anständiger nazi.
 Arnoud Veilbrief Kristallnacht? Viel me niet op, in NRC Handelsblad, Cultureel Supplement, 1 september 2006.
 Esther Villar: Speer. (toneelstuk)

Verder bestaat er een boek Die intelligente Stadt, auteur Albert Speer, maar in dit geval betreft het Speers oudste zoon.

 Film 
 Inside the Third Reich (1982): een film gebaseerd op het boek Die Spandauer Tagebücher met Rutger Hauer in de hoofdrol.
 Speer en Hitler (oorspronkelijke titel Speer und Er): een gedramatiseerde documentaire over Albert Speer uit 2004 door Heinrich Breloer.
 Der Untergang'': oorlogsfilm uit 2004, gespeeld door Heino Ferch.

Duits architect
Duits minister van Economie
Duits persoon in de Tweede Wereldoorlog
Minister van nazi-Duitsland
NSDAP-lid

;(function(window) {
  'use strict';

  /** The base path of the lodash builds. */
  var basePath = '../';

  /** The lodash build to load. */
  var build = (build = /build=([^&]+)/.exec(location.search)) && decodeURIComponent(build[1]);

  /** The module loader to use. */
  var loader = (loader = /loader=([^&]+)/.exec(location.search)) && decodeURIComponent(loader[1]);

  /** The `ui` object. */
  var ui = {};

  /*--------------------------------------------------------------------------*/

  // Initialize controls.
  addEventListener('load', function() {
    function eventHandler(event) {
      var buildIndex = buildList.selectedIndex,
          loaderIndex = loaderList.selectedIndex,
          search = location.search.replace(/^\?|&?(?:build|loader)=[^&]*&?/g, '');

      if (event.stopPropagation) {
        event.stopPropagation();
      } else {
        event.cancelBubble = true;
      }
      location.href =
        location.href.split('?')[0] + '?' +
        (search ? search + '&' : '') +
        'build=' + (buildIndex < 0 ? build : buildList[buildIndex].value) + '&' +
        'loader=' + (loaderIndex < 0 ? loader : loaderList[loaderIndex].value);
    }

    function init() {
      var toolbar = document.getElementById('qunit-testrunner-toolbar');
      if (!toolbar) {
        setTimeout(init, 15);
        return;
      }
      toolbar.insertBefore(span2, toolbar.lastChild);
      toolbar.insertBefore(span1, span2);

      buildList.selectedIndex = (function() {
        switch (build) {
          case 'lodash':            return 1;
          case 'lodash-core-dev':   return 2;
          case 'lodash-core':       return 3;
          case 'lodash-dev':
          case null:                return 0;
        }
        return -1;
      }());

      loaderList.selectedIndex = (function() {
        switch (loader) {
          case 'curl':      return 1;
          case 'dojo':      return 2;
          case 'requirejs': return 3;
          case 'none':
          case null:        return 0;
        }
        return -1;
      }());

      buildList.addEventListener('change', eventHandler);
      loaderList.addEventListener('change', eventHandler);
    }

    var span1 = document.createElement('span');
    span1.innerHTML =
      '<label for="qunit-build">Build: </label>' +
      '<select id="qunit-build">' +
      '<option value="lodash-dev">lodash (development)</option>' +
      '<option value="lodash">lodash (production)</option>' +
      '<option value="lodash-core-dev">lodash-core (development)</option>' +
      '<option value="lodash-core">lodash-core (production)</option>' +
      '</select>';

    var span2 = document.createElement('span');
    span2.innerHTML =
      '<label for="qunit-loader">Loader: </label>' +
      '<select id="qunit-loader">' +
      '<option value="none">None</option>' +
      '<option value="curl">Curl</option>' +
      '<option value="dojo">Dojo</option>' +
      '<option value="requirejs">RequireJS</option>' +
      '</select>';

    span1.style.cssText =
    span2.style.cssText = 'display:inline-block;float:right;line-height:2.1em;margin-left:1em;margin-top:0;';

    span1.firstChild.style.cssText =
    span2.firstChild.style.cssText = 'display:inline-block;margin-right:.5em;';

    var buildList = span1.lastChild,
        loaderList = span2.lastChild;

    setTimeout(function() {
      ui.timing.loadEventEnd = +new Date;
    }, 1);

    init();
  });

  // The lodash build file path.
  ui.buildPath = (function() {
    var result;
    switch (build) {
      case 'lodash':            result = 'dist/lodash.min.js'; break;
      case 'lodash-core-dev':   result = 'dist/lodash.core.js'; break;
      case 'lodash-core':       result = 'dist/lodash.core.min.js'; break;
      case null:                build  = 'lodash-dev';
      case 'lodash-dev':        result = 'lodash.js'; break;
      default:                  return build;
    }
    return basePath + result;
  }());

  // The module loader file path.
  ui.loaderPath = (function() {
    var result;
    switch (loader) {
      case 'curl':      result = 'node_modules/curl-amd/dist/curl-kitchen-sink/curl.js'; break;
      case 'dojo':      result = 'node_modules/dojo/dojo.js'; break;
      case 'requirejs': result = 'node_modules/requirejs/require.js'; break;
      case null:        loader = 'none'; return '';
      default:          return loader;
    }
    return basePath + result;
  }());

  // Used to indicate testing a core build.
  ui.isCore = /\bcore(\.min)?\.js\b/.test(ui.buildPath);

  // Used to indicate testing a foreign file.
  ui.isForeign = RegExp('^(\\w+:)?//').test(build);

  // Used to indicate testing a modularized build.
  ui.isModularize = /\b(?:amd|commonjs|es|node|npm|(index|main)\.js)\b/.test([location.pathname, location.search]);

  // Used to indicate testing in Sauce Labs' automated test cloud.
  ui.isSauceLabs = location.port == '9001';

  // Used to indicate that lodash is in strict mode.
  ui.isStrict = /\bes\b/.test([location.pathname, location.search]);

  ui.urlParams = { 'build': build, 'loader': loader };
  ui.timing = { 'loadEventEnd': 0 };

  window.ui = ui;

}(this));

log
===

A Rust library providing a lightweight logging *facade*.

[![Build status](https://img.shields.io/github/actions/workflow/status/rust-lang/log/main.yml?branch=master)](https://github.com/rust-lang/log/actions)
[![Latest version](https://img.shields.io/crates/v/log.svg)](https://crates.io/crates/log)
[![Documentation](https://docs.rs/log/badge.svg)](https://docs.rs/log)
![License](https://img.shields.io/crates/l/log.svg)

* [`log` documentation](https://docs.rs/log)

A logging facade provides a single logging API that abstracts over the actual
logging implementation. Libraries can use the logging API provided by this
crate, and the consumer of those libraries can choose the logging
implementation that is most suitable for its use case.


## Minimum supported `rustc`

See the `rust-version` field in `Cargo.toml` for the current minimum Rust toolchain version.

This version is explicitly tested in CI and may be bumped in any release as needed. Maintaining compatibility with older compilers is a priority though, so the bar for bumping the minimum supported version is set very high. Any changes to the supported minimum version will be called out in the release notes.

## Usage

### In libraries

Libraries should link only to the `log` crate, and use the provided macros to
log whatever information will be useful to downstream consumers:

```toml
[dependencies]
log = "0.4"
```

```rust
use log::{info, trace, warn};

pub fn shave_the_yak(yak: &mut Yak) {
    trace!("Commencing yak shaving");

    loop {
        match find_a_razor() {
            Ok(razor) => {
                info!("Razor located: {razor}");
                yak.shave(razor);
                break;
            }
            Err(err) => {
                warn!("Unable to locate a razor: {err}, retrying");
            }
        }
    }
}
```

### In executables

In order to produce log output, executables have to use a logger implementation compatible with the facade.
There are many available implementations to choose from, here are some options:

* Simple minimal loggers:
    * [`env_logger`](https://docs.rs/env_logger/*/env_logger/)
    * [`colog`](https://docs.rs/colog/*/colog/)
    * [`simple_logger`](https://docs.rs/simple_logger/*/simple_logger/)
    * [`simplelog`](https://docs.rs/simplelog/*/simplelog/)
    * [`pretty_env_logger`](https://docs.rs/pretty_env_logger/*/pretty_env_logger/)
    * [`stderrlog`](https://docs.rs/stderrlog/*/stderrlog/)
    * [`flexi_logger`](https://docs.rs/flexi_logger/*/flexi_logger/)
    * [`call_logger`](https://docs.rs/call_logger/*/call_logger/)
    * [`std-logger`](https://docs.rs/std-logger/*/std_logger/)
    * [`structured-logger`](https://docs.rs/structured-logger/latest/structured_logger/)
    * [`clang_log`](https://docs.rs/clang_log/latest/clang_log)
    * [`ftail`](https://docs.rs/ftail/latest/ftail/)
* Complex configurable frameworks:
    * [`log4rs`](https://docs.rs/log4rs/*/log4rs/)
    * [`logforth`](https://docs.rs/logforth/*/logforth/)
    * [`fern`](https://docs.rs/fern/*/fern/)
    * [`spdlog-rs`](https://docs.rs/spdlog-rs/*/spdlog/)
* Adaptors for other facilities:
    * [`syslog`](https://docs.rs/syslog/*/syslog/)
    * [`systemd-journal-logger`](https://docs.rs/systemd-journal-logger/*/systemd_journal_logger/)
    * [`slog-stdlog`](https://docs.rs/slog-stdlog/*/slog_stdlog/)
    * [`android_log`](https://docs.rs/android_log/*/android_log/)
    * [`win_dbg_logger`](https://docs.rs/win_dbg_logger/*/win_dbg_logger/)
    * [`db_logger`](https://docs.rs/db_logger/*/db_logger/)
    * [`log-to-defmt`](https://docs.rs/log-to-defmt/*/log_to_defmt/)
    * [`logcontrol-log`](https://docs.rs/logcontrol-log/*/logcontrol_log/)
* For WebAssembly binaries:
    * [`console_log`](https://docs.rs/console_log/*/console_log/)
* For dynamic libraries:
    * You may need to construct [an FFI-safe wrapper over `log`](https://github.com/rust-lang/log/issues/421) to initialize in your libraries.
* Utilities:
    * [`log_err`](https://docs.rs/log_err/*/log_err/)
    * [`log-reload`](https://docs.rs/log-reload/*/log_reload/)
    * [`alterable_logger`](https://docs.rs/alterable_logger/*/alterable_logger)
    * [`context-logger`](https://docs.rs/context-logger/*/context_logger)

Executables should choose a logger implementation and initialize it early in the
runtime of the program. Logger implementations will typically include a
function to do this. Any log messages generated before the logger is
initialized will be ignored.

The executable itself may use the `log` crate to log as well.

## Structured logging

If you enable the `kv` feature, you can associate structured data with your log records:

```rust
use log::{info, trace, warn};

pub fn shave_the_yak(yak: &mut Yak) {
    // `yak:serde` will capture `yak` using its `serde::Serialize` impl
    //
    // You could also use `:?` for `Debug`, or `:%` for `Display`. For a
    // full list, see the `log` crate documentation
    trace!(target = "yak_events", yak:serde; "Commencing yak shaving");

    loop {
        match find_a_razor() {
            Ok(razor) => {
                info!(razor; "Razor located");
                yak.shave(razor);
                break;
            }
            Err(e) => {
                // `e:err` will capture `e` using its `std::error::Error` impl
                warn!(e:err; "Unable to locate a razor, retrying");
            }
        }
    }
}
```

est un réalisateur, producteur, scénariste et monteur japonais, né le  à Tokyo, où il est mort le . Il est considéré comme l’un des cinéastes les plus célèbres et influents de l’histoire du cinéma. En cinquante-sept ans de carrière cinématographique, il a réalisé plus de trente films.

Après une brève expérience de peintre, Akira Kurosawa entre dans l’industrie cinématographique japonaise en 1936 en tant qu’assistant réalisateur et scénariste. Il fait ses débuts en tant que réalisateur pendant la Seconde Guerre mondiale avec le film d’action populaire . Son huitième long métrage, , sort en 1948 et est acclamé par la critique, consolidant sa réputation. Ce film marque les débuts de sa collaboration avec l’acteur Toshirō Mifune, qui va tourner dans seize de ses films.

Pour , dont la première a lieu à Tokyo en , Akira Kurosawa reçoit le Lion d’or de la Mostra de Venise. Cette récompense inattendue permet au film d’être diffusé en Europe et en Amérique du Nord. Son succès public et critique ouvre les portes de l’Occident au cinéma japonais et permet à d’autres cinéastes japonais d’obtenir une reconnaissance internationale. Des  au début des , Kurosawa réalise environ un film par an, dont ,  et . Au début des , il devient beaucoup moins prolifique, mais ses œuvres tardives  continuent de remporter des prix, dont la Palme d’or au Festival de Cannes pour Kagemusha.
 
En 1990, il reçoit l’Oscar d’honneur décerné par l’ . En 1999, il est nommé à titre posthume « Personnalité asiatique du siècle » dans la catégorie « Arts, littérature, et culture » par le magazine Asiaweek et CNN, présenté comme .

Biographie

Enfance et éducation cinématographique (1910-1935) 
Kurosawa naît le  dans le quartier de Higashiōi (arrondissement de Shinagawa) à Tokyo. Son père Isamu, descendant d’une famille de samouraïs de la préfecture d’Akita, est directeur de l’école secondaire de l’Institut d’éducation physique de l’armée, tandis que sa mère vient d’une famille de marchands d’Osaka. Il est le benjamin d’une lignée de sept enfants. Deux d’entre eux sont presqu’adultes à sa naissance, et une de ses sœurs meurt peu de temps après. Kurosawa ne grandit alors qu’avec trois de ses frères et sœurs.

En plus de promouvoir l’exercice physique, son père, Isamu Kurosawa, considère la culture occidentale  comme un point essentiel de l’éducation : le jeune Akira découvre le cinéma à l’âge de . Sous l’influence d’un de ses professeurs d’école élémentaire, , il se passionne pour la peinture et le dessin. À cette époque, il étudie également la calligraphie et le kendo.

L’enfance d’Akira Kurosawa est également très influencée par son frère Heigo, de quatre ans son aîné. Kurosawa rapporte qu’à la suite du séisme du Kantō de 1923, Heigo l’emmène dans les quartiers les plus détruits de la capitale et que lorsqu’il tente de détourner les yeux des cadavres jonchant les rues, son frère l’en empêche pour l’obliger à affronter ses peurs. Pour certains critiques, cet événement a fortement influencé la sensibilité de Kurosawa.

Heigo est un élève brillant, mais échoue à son examen d’entrée au lycée. À la suite de cet échec, il se détache peu à peu de sa famille, et se concentre sur la littérature étrangère. À la fin des années 1920, Heigo devient benshi (commentateur de films muets) et se fait connaître sous le nom de Suda Teimei. Akira, qui veut alors devenir peintre de style occidental, emménage avec son frère. Grâce à Heigo, Akira découvre non seulement le cinéma, mais également le théâtre et le cirque. Dans le même temps, il expose ses toiles et travaux dans le cadre des expositions de la Ligue des artistes prolétariens. Mais il n’arrive pas à vivre de sa peinture et finit par s’en lasser. Il se détourne aussi de la politique alors que la répression policière s’est accentuée.

Avec l’avènement du cinéma parlant au début des années 1930, il devient difficile pour les benshi comme Heigo de trouver du travail, et Akira retourne chez ses parents. En , Heigo se suicide avec sa compagne. Kurosawa décrit cette mort comme un sentiment durable de perte, et l’évoque dans le chapitre intitulé « Une histoire dont je ne veux pas parler » de son autobiographie. Seulement quatre mois après la mort de Heigo, son frère aîné meurt également.

Apprentissage de la réalisation (1935-1941) 

En 1935, le nouveau studio de cinéma « Photo Chemical Laboratories »  recherche des assistants réalisateurs. Bien qu’il n’ait jamais envisagé de travailler dans le cinéma et qu’il ait déjà un travail d’illustrateur de livres, Kurosawa répond à l’annonce du studio, qui demande aux candidats de rédiger un essai sur les défauts fondamentaux des films japonais et les moyens d’y remédier. Kurosawa explique dans son papier que si ces défauts sont fondamentaux, alors il n’y a aucun moyen de les corriger. Cette lettre au ton moqueur lui permet de passer les examens suivants. Le réalisateur Kajirō Yamamoto, qui fait partie des recruteurs, insiste pour que Kurosawa soit embauché. En , à l’âge de , Kurosawa entre chez PCL.

Au cours de ses cinq années en tant qu’assistant, Kurosawa travaille pour un nombre important de réalisateurs différents, mais celui qui lui apporte le plus reste Kajirō Yamamoto. Sur ses vingt-quatre films en tant qu’assistant réalisateur, dix-sept sont réalisés par Yamamoto, la plupart étant des comédies jouées par l’acteur Ken’ichi Enomoto, plus connu sous le nom de « Enoken ». Yamamoto cultive le talent de Kurosawa et le fait passer en une année de troisième assistant à « assistant réalisateur en chef ». Les responsabilités de Kurosawa s’accroissent, et son travail va de l’élaboration des scènes et du développement du film aux repérages des lieux de tournage, en passant par la finition du scénario, les répétitions, l’éclairage, le doublage, le montage et la direction de la seconde équipe. Dans son dernier film en tant qu’assistant réalisateur, , Kurosawa prend en charge l’essentiel de la production, Yamamoto étant déjà occupé par le tournage d’un autre film.

Yamamoto confie à Kurosawa qu’un bon réalisateur doit avant tout être un excellent scénariste. Kurosawa comprend alors qu’il peut être davantage rémunéré en écrivant des scénarios plutôt qu’en restant assistant réalisateur. Par la suite, il écrit ou coécrit tous ses films, et écrit fréquemment des scénarios pour d’autres réalisateurs, comme celui du film  de Satsuo Yamamoto. L’écriture de scénarios pour d’autres réalisateurs est pour Kurosawa une activité lucrative, qui dure jusque dans les années 1960, bien après qu’il soit devenu célèbre.

Guerre, censure et mariage (1942-1945) 
Durant les deux ans suivant la sortie de Cheval en 1941, Kurosawa est en quête d’une histoire qui pourrait lancer sa carrière de réalisateur. Vers la fin de l’année 1942, environ un an après le début de la guerre entre le Japon et les États-Unis, le romancier Tsuneo Tomita publie Sugata Sanshirō, un roman sur la naissance du judo écrit dans le style de Miyamoto Musashi. Intrigué par le livre, Kurosawa l’achète le jour de sa publication ; après l’avoir lu d’une traite, il demande immédiatement à la Tōhō d’en acquérir les droits d’adaptation. Son intuition s’est avérée juste puisque, en l’espace de quelques jours, trois autres grands studios japonais proposent également d’acheter les droits. La Tōhō finit par les obtenir, et Kurosawa entame la préproduction de son premier film en tant que réalisateur.

Le tournage de  débute à Yokohama en . La production du film ne pose pas de problème, mais la censure, qui avait donné son accord en amont conformément à la loi sur le cinéma de 1939, juge le résultat du tournage trop . La Légende du grand judo doit finalement sa sortie le  au réalisateur Yasujirō Ozu, qui défend le film. Néanmoins, dix-huit minutes de la version initiale sont censurées. La plupart de ces coupes sont aujourd’hui considérées comme définitivement perdues. La Légende du grand judo est un film caractéristique de l’idéologie de l’époque. Il exalte les vertus morales et l’abnégation du petit peuple, par opposition à l’égoïsme et à la méchanceté des bourgeois occidentalisés, représentés par le personnage de Gennosuke.

Kurosawa s’intéresse ensuite au sujet des femmes ouvrières en temps de guerre dans , un film de propagande tourné dans un style semi-documentaire au début de l’année 1944. Le scénario, écrit par Kurosawa, met en scène un groupe de jeunes ouvrières dans une usine de lentilles optiques à usage militaire qui fait tout son possible malgré les difficultés pour augmenter sa productivité. Pour obtenir des performances réalistes de la part des actrices, Kurosawa les fait vivre dans une véritable usine pendant le tournage, manger la nourriture de l’usine et s’appeler les unes les autres par les noms de leurs personnages. Il utilise des méthodes similaires avec ses interprètes tout au long de sa carrière.

Au cours de la production, Yōko Yaguchi, l’actrice interprétant la meneuse du groupe d’ouvrières, est choisie par ses collègues pour présenter à Kurosawa leurs exigences. Paradoxalement, alors qu’ils s’opposent en permanence, Yaguchi et Kurosawa se rapprochent. Ils se marient le , alors que Yōko est enceinte de deux mois. Ils restent mariés jusqu’à la mort de Yōko en 1985. Ils ont ensemble deux enfants : un fils, Hisao, né le , producteur de quelques-uns des derniers projets de son père, et une fille, Kazuko, née le , chef costumière.

Juste avant son mariage, Kurosawa est pressé par le studio de donner une suite à La Légende du grand judo. Le film de propagande  sort en , et est souvent considéré comme l’une des œuvres les moins abouties de Kurosawa.

Dans le contexte de pénurie des derniers mois de la guerre, Kurosawa décide d’écrire le scénario d’un film moins onéreux à produire que les précédents. , basé sur la pièce de kabuki Kanjinchō, avec Enoken, est achevé en . À cette date, le Japon vient de capituler, et l’occupation du pays par les Alliés a commencé. Le système de censure mis en place par les Américains, à l’encontre de tous les films japonais réalisés pendant la guerre, bloque la diffusion du film, estimant qu’il défend des valeurs . Le film avait déjà été critiqué par les censeurs japonais en temps de guerre, qui le jugeaient trop occidental et . Ils regrettaient notamment le rôle du porteur comique interprété par Enoken. Le film n’aurait donc probablement pas vu le jour même si la guerre s’était poursuivie plus longtemps. Il ne sort finalement qu’en 1952, sept ans après son tournage.

Travaux d'après-guerre (1946-1950) 
Au lendemain de la guerre, Kurosawa est inspiré par les idéaux démocratiques du nouveau régime né de l’occupation. Le premier film résultant de cette inspiration est , sorti en 1946, basé sur l’incident de Takigawa de 1933 et l’affaire de l’espion Hotsumi Ozaki, dans lequel le réalisateur critique le régime japonais d’avant-guerre. Le personnage central du film est une femme, Yukie (interprétée par Setsuko Hara), qui cherche sa place dans un contexte de crise politique. Le scénario original, écrit par Eijirō Hisaita, doit être revu et corrigé de façon importante en raison de ses thèmes politiques. Le film divise la critique, tant par son sujet controversé que par le sexe de son personnage principal. En revanche, le succès auprès du public est présent, et le titre du film devient une phrase culte d’après-guerre.

Son film suivant, , sort en  et reçoit un accueil critique mitigé. Il s’agit de l’histoire d’amour relativement simple d’un couple appauvri par la guerre qui souhaite profiter de son jour de repos. Pour ce film, Kurosawa est influencé par les œuvres de Frank Capra, D. W. Griffith et F. W. Murnau, des cinéastes qu’il admire profondément. En 1947 sort , un film de Senkichi Taniguchi et écrit par Kurosawa. Ce film marque les débuts du jeune acteur Toshirō Mifune. C’est Kurosawa, avec l’aide de Yamamoto, qui insiste pour que le studio Tōhō engage Mifune.

L’année suivante sort . Bien que le scénario doive être réécrit à cause de la censure de l’occupation, Kurosawa a le sentiment de pouvoir enfin s’exprimer librement. Le film raconte l’histoire d’un médecin tentant de sauver un yakuza de la tuberculose. Il s’agit de la première collaboration entre le réalisateur et Mifune. Cette collaboration se poursuit durant les seize films suivants du cinéaste (hormis Vivre), où Mifune joue les premiers rôles. À l’origine, Mifune n’est pas censé jouer le personnage principal de L’Ange ivre, mais sa prestation de yakuza est telle qu’il domine le film et éclipse le rôle du docteur alcoolique tenu par Takashi Shimura. Kurosawa décide alors de ne pas gêner la montée en puissance du jeune acteur. Le jeu de rebelle de Mifune conquiert aussitôt le public. L’avant-première a lieu en , et le film est élu meilleur film de l’année par la prestigieuse revue Kinema Junpō. Au total, trois films de Kurosawa seront ainsi récompensés.

Avec le producteur Sōjirō Motoki et les réalisateurs Kajirō Yamamoto, Mikio Naruse et Senkichi Taniguchi, Kurosawa fonde l’. Pour les débuts de cette organisation, et pour son premier film pour Daiei, Kurosawa adapte avec Taniguchi une pièce contemporaine de Kazuo Kikuta.  a pour tête d’affiche Toshirō Mifune en jeune médecin idéaliste luttant contre la syphilis. Il s’agit d’une tentative délibérée de Kurosawa de sortir Mifune des rôles de gangsters. Sorti en , le film est un succès au box-office, mais est généralement considéré comme l’un des moins bons du cinéaste.

Son second film de l’année 1949, également produit par l’Association artistique cinématographique et distribué par la Shintōhō, est , l’un de ses films les plus célèbres. Ce film policier raconte l’histoire d’un jeune détective (interprété par Mifune) obsédé par son pistolet volé par un démuni qui s’en sert pour commettre des crimes. Il est chargé d’assister le commissaire Sato, dont la perspicacité pour remonter jusqu’au coupable rappelle celle du commissaire Maigret. Adapté d’un roman de Kurosawa lui-même, et écrit dans le style de l’un de ses auteurs favoris , il s’agit avant tout de sa première collaboration avec le scénariste Ryūzō Kikushima. L’une des séquences les plus célèbres du film, d’une durée de huit minutes et sans dialogues, représente le jeune détective déguisé en pauvre vétéran errant dans les rues à la recherche de son arme ; cette séquence utilise des plans d’un documentaire sur la ville de Tokyo ravagée par la guerre, réalisé par Ishirō Honda, un ami de Kurosawa et futur réalisateur de .

, produit par la Shōchiku et sorti en , est inspiré d’une expérience personnelle du réalisateur avec la presse à scandale. Le film mêle drame judiciaire et problèmes sociaux sur fond de liberté d’expression et de responsabilités personnelles. Mais Kurosawa juge le travail flou et peu satisfaisant, rejoignant ce que s’accorde à dire la majorité des critiques. Cependant, c’est avec son second film de 1950, , que Kurosawa finit par gagner un tout nouveau public.

Reconnaissance internationale (1950-1958) 
Après la sortie de Scandale, Kurosawa est approché par les studios Daiei, afin qu’il réalise un deuxième film pour eux après Le Duel silencieux. Le réalisateur choisit alors le script d’un jeune scénariste, Shinobu Hashimoto, basé sur la nouvelle de Ryūnosuke Akutagawa intitulée  qui narre le meurtre d’un samouraï et le viol de sa femme. Kurosawa voit dans cette nouvelle un potentiel cinématographique, et décide de la développer avec l’aide de Hashimoto. Daiei accueille le projet avec enthousiasme d’autant que le budget requis semble faible avec ses deux uniques décors et un tournage majoritairement en extérieur. Matsutarō Kawaguchi, alors cadre à la Daiei, se plaindra plus tard auprès de Kurosawa d’avoir été roulé tant l’imposant décor de la porte Rashō a été couteux.

Le tournage de Rashōmon se déroule du  au  dans les grands espaces montagneux de la forêt de Nara puis dans la forêt qui longe le Konkai kōmyō-ji à Kyoto. La post-production du film dure une seule semaine, et est gênée par un incendie dans les studios. L’avant-première a lieu le  au théâtre impérial de Tokyo, la sortie nationale le lendemain. Les critiques sont partagées, intriguées par le thème unique du film. Il s’agit néanmoins d’un succès financier modéré pour la société Daiei.

Le film suivant de Kurosawa, pour Shōchiku, est , une adaptation du roman de l’écrivain préféré du réalisateur, Fiodor Dostoïevski. Le cinéaste délocalise l’histoire de la Russie à Hokkaidō, mais reste très fidèle à l’œuvre originale, ce que de nombreuses critiques jugent dommageable pour le film. Jugé trop long, le film de Kurosawa est raccourci, passant de  (près de ) à , ce qui rend l’histoire difficilement compréhensible. À sa sortie, les critiques sont très mauvaises, mais le film rencontre un succès modéré auprès du public, essentiellement grâce à la présence de Setsuko Hara.

Pendant ce temps, à l’insu de Kurosawa, Rashōmon est sélectionné à la Mostra de Venise grâce aux efforts de Giuliana Stramigioli, une représentante basée au Japon d’une société de production italienne. Le , Rashōmon reçoit la plus haute distinction du festival, le Lion d’or. Cette récompense surprend l’ensemble du monde du cinéma, qui à l’époque ignorait quasiment tout de la tradition cinématographique du Japon.

Daiei exploite alors brièvement le film à Los Angeles jusqu’à ce que RKO rachète les droits de distribution sur le sol des États-Unis. Le risque est grand pour RKO : à l’époque, un seul film sous-titré est sur le marché américain, et le seul film japonais ayant été distribué à New York, une comédie de Mikio Naruse en 1937, a été un échec critique et commercial. Pourtant, l’exploitation de Rashōmon est un succès, aidée par de nombreux critiques dont Ed Sullivan : lors des trois premières semaines, le film engrange , et ce dans un seul cinéma de New York. Le public français quant à lui découvre le film en salles en . Ce succès entraîne un regain d’intérêt pour les films japonais en Occident dans les , éclipsant le cinéma néoréaliste italien. Grâce à cette renommée, les films d’autres cinéastes japonais commencent à recevoir des récompenses et à être distribués en Occident, comme ceux de Kenji Mizoguchi, et plus tard ceux de Yasujirō Ozu, des cinéastes reconnus au Japon mais totalement inconnus dans cette partie du monde.

Sa carrière gonflée par sa reconnaissance internationale, Kurosawa retourne chez Tōhō et travaille sur son prochain film, . Le film met en scène Watanabe (Takashi Shimura), un fonctionnaire atteint d’un cancer qui cherche à donner un dernier sens à sa vie. Pour le scénario, Kurosawa s’allie à Hashimoto et à l’écrivain Hideo Oguni, avec qui il coécrit douze films. Malgré le sujet grave, les scénaristes abordent le récit d’une manière satirique, ce que certains comparent au travail de Bertolt Brecht. Cette stratégie leur a permis d’éviter ce sentimentalisme commun qui règne habituellement autour de personnages atteints de maladies incurables. Vivre sort en , Kurosawa est récompensé de son deuxième « meilleur film » de Kinema Junpō, et le film remporte un grand succès au box-office.

En , Kurosawa s’isole durant  avec les deux scénaristes de Ikiru, Shinobu Hashimoto et Hideo Oguni. Ensemble, ils écrivent le scénario du prochain film du cinéaste, . Il s’agit du premier véritable chanbara de Kurosawa, genre pour lequel il est aujourd’hui le plus connu. L’histoire, celle d’un pauvre village de l’époque Sengoku qui fait appel à un groupe de samouraïs afin de se défendre des bandits, est traitée par Kurosawa d’une manière totalement épique, et l’action est méticuleusement détaillée durant les trois heures et demie. Le film s’appuie sur une distribution d’ensemble impressionnante, composée notamment d’acteurs ayant déjà tourné avec Kurosawa.

Trois mois sont nécessaires pour la préproduction, un mois pour les répétitions. Le tournage dure  étalés sur près d’un an, interrompu entre autres par des difficultés de production et d’ordre financier, ainsi que par les problèmes de santé de Kurosawa. Le film sort finalement en , soit  après la date prévue. Le film coûte trois fois plus que prévu, et devient alors le film japonais le plus cher jamais réalisé. Les critiques sont positives, et le succès au box-office permet de rentrer rapidement dans les frais. Après de nombreuses modifications, il est distribué sur le marché international. Au fil du temps, et grâce aux versions non modifiées diffusées par la suite, le film accroît sa notoriété. En 1979, un vote parmi des critiques japonais le classe comme étant le meilleur film japonais de tous les temps. Aujourd’hui encore, il est considéré comme tel par certains critiques.

En 1954, des tests nucléaires militaires dans le Pacifique créent des incidents aux conséquences désastreuses, comme celui impliquant le thonier japonais Daigo Fukuryū Maru. C’est dans cette anxiété ambiante que Kurosawa conçoit son film suivant, . Le propos porte sur un riche industriel (Toshirō Mifune) terrifié à l’idée d’une attaque nucléaire, et qui décide d’emmener sa famille dans une ferme au Brésil pour être en sécurité. La production est moins chaotique que lors du film précédent, mais à quelques jours de la fin du tournage, Fumio Hayasaka, compositeur et ami de Kurosawa, meurt de la tuberculose. La bande originale est alors achevée par l’assistant de Hayasaka, Masaru Satō, qui travaille sur les huit films suivants de Kurosawa. Vivre dans la peur sort en , mais l’accueil des critiques et du public est timide et réservé. Le film devient alors le premier de Kurosawa à ne pas rentrer dans ses frais durant son exploitation en salle. Aujourd’hui, il est considéré comme le meilleur film traitant des effets psychologiques de la paralysie nucléaire mondiale.

Le projet suivant de Kurosawa, , est une adaptation du Macbeth de William Shakespeare, dont l’histoire est transposée en Asie à l’époque Sengoku. Kurosawa donne pour instruction aux acteurs, et notamment à l’actrice principale Isuzu Yamada, d’agir et de jouer comme s’il s’agissait d’un classique de la littérature japonaise et non occidentale. Le jeu des acteurs s’apparente alors aux techniques et styles du théâtre nô. Le film est tourné en 1956 et sort en . Le succès en salle est légèrement moins mauvais que pour Vivre dans la peur. À l’étranger, le film devient rapidement une référence parmi les adaptations cinématographiques de Shakespeare.

La production d’une autre adaptation d’un classique européen suit immédiatement celle du Château de l’araignée. , adapté de la pièce du même nom de Maxime Gorki, est réalisé en mai et . Bien que l’adaptation soit très fidèle à la pièce de théâtre russe, l’exercice de transposition à l’époque d’Edo est considéré comme une réussite artistique. La première a lieu en , et le film reçoit un accueil partagé, similaire à celui reçu par Le Château de l’araignée. Certains critiques le classent parmi les œuvres les plus sous-estimées de Kurosawa.

Les trois films suivant Les Sept Samouraïs n’ont pas connu le même succès auprès du public japonais. Le travail de Kurosawa est de plus en plus sombre et pessimiste, et le réalisateur aborde les questions de la rédemption. Kurosawa, qui s’aperçoit de ces changements, décide délibérément de retourner à des films plus légers et divertissants. À cette même époque, le format écran large devient très populaire au Japon. En résulte , film d’action et d’aventure mettant en scène une princesse, son fidèle général et deux paysans devant traverser les lignes ennemies pour pouvoir rejoindre leurs foyers. Sorti en 1958, La Forteresse cachée est un énorme succès au box-office, et est chaudement accueilli par les critiques. Aujourd’hui, le film est considéré comme l’un des films les plus légers et accessibles de Kurosawa, mais reste très populaire pour ses nombreuses influences, notamment sur Star Wars, le  de George Lucas sorti en 1977.

Naissance d'une entreprise et fin d'une ère (1959-1965) 
Depuis Rashōmon, les films de Kurosawa atteignent un public plus large, et la fortune du réalisateur a

# Contributing to Lodash

Contributions are always welcome. Before contributing please read the
[code of conduct](https://github.com/openjs-foundation/cross-project-council/blob/main/CODE_OF_CONDUCT.md) &
[search the issue tracker](https://github.com/lodash/lodash/issues); your issue
may have already been discussed or fixed in `master`. To contribute,
[fork](https://help.github.com/articles/fork-a-repo/) Lodash, commit your changes,
& [send a pull request](https://help.github.com/articles/using-pull-requests/).

## Feature Requests

Feature requests should be submitted in the
[issue tracker](https://github.com/lodash/lodash/issues), with a description of
the expected behavior & use case, where they’ll remain closed until sufficient interest,
[e.g. :+1: reactions](https://help.github.com/articles/about-discussions-in-issues-and-pull-requests/),
has been [shown by the community](https://github.com/lodash/lodash/issues?q=label%3A%22votes+needed%22+sort%3Areactions-%2B1-desc).
Before submitting a request, please search for similar ones in the
[closed issues](https://github.com/lodash/lodash/issues?q=is%3Aissue+is%3Aclosed+label%3Aenhancement).

## Pull Requests

For additions or bug fixes you should only need to modify `lodash.js`. Include
updated unit tests in the `test` directory as part of your pull request. Don’t
worry about regenerating the `dist/` or `doc/` files.

Before running the unit tests you’ll need to install, `npm i`,
[development dependencies](https://docs.npmjs.com/files/package.json#devdependencies).
Run unit tests from the command-line via `npm test`, or open `test/index.html` &
`test/fp.html` in a web browser. The [Backbone](http://backbonejs.org/) &
[Underscore](http://underscorejs.org/) test suites are included as well.

## Contributor License Agreement

Lodash is a member of the [Open JS Foundation](https://openjsf.org/).
As such, we request that all contributors sign our
[contributor license agreement (CLA)](https://openjsf.org/cla).

For more information about CLAs, please check out Alex Russell’s excellent post,
[“Why Do I Need to Sign This?”](https://infrequently.org/2008/06/why-do-i-need-to-sign-this/).

## Coding Guidelines

In addition to the following guidelines, please follow the conventions already
established in the code.

- **Spacing**:<br>
  Use two spaces for indentation. No tabs.

- **Naming**:<br>
  Keep variable & method names concise & descriptive.<br>
  Variable names `index`, `array`, & `iteratee` are preferable to
  `i`, `arr`, & `fn`.

- **Quotes**:<br>
  Single-quoted strings are preferred to double-quoted strings; however,
  please use a double-quoted string if the value contains a single-quote
  character to avoid unnecessary escaping.

- **Comments**:<br>
  Please use single-line comments to annotate significant additions, &
  [JSDoc-style](http://www.2ality.com/2011/08/jsdoc-intro.html) comments for
  functions.

Guidelines are enforced using [JSCS](https://www.npmjs.com/package/jscs):
```bash
$ npm run style
```

## Tips

You can opt-in to a pre-push git hook by adding an `.opt-in` file to the root of
the project containing:
```txt
pre-push
```

With that, when you `git push`, the pre-push git hook will trigger and execute
`npm run validate`.

> [!IMPORTANT]
> As announced on the [OpenJS Foundation blog](https://openjsf.org/blog/sta-supports-lodash), Lodash has received support from the Sovereign Tech Agency and will transition to the Feature-Complete maturity stage so that it remains stable, secure, and sustainable long-term. As part of this effort, Lodash is rebooting its governance. A draft charter will be published shortly. The upcoming Technical Steering Committee (TSC) is already at work. For transparency, its members are listed below.

# Lodash Governance

## Technical Steering Committee Members

The current Technical Steering Committee (TSC) members are:

- John-David Dalton ([@jdalton](https://github.com/jdalton)), _(Lodash creator)_
- Jon Church ([@jonchurch](https://github.com/jonchurch))
- Jordan Harband ([@ljharb](https://github.com/ljharb))
- Michał Lipiński ([@falsyvalues](https://github.com/falsyvalues))
- Tobie Langel ([@tobie](https://github.com/tobie))
- Ulises Gascón ([@ulisesgascon](https://github.com/UlisesGascon))

## Security Triage Team

The Security Triage Team is responsible for assessing and managing vulnerability and incident reports. Security triaging is currently handled by the [TSC](#technical-steering-committee-members).

## Release Team

The Release Team is solely responsible for publishing new versions of Lodash to npm. Its current member is:

- John-David Dalton ([@jdalton](https://github.com/jdalton))

(handling-files)=

# Handling Files

```{currentmodule} click
```

Click has built in features to support file and file path handling. The examples use arguments but the same principle
applies to options as well.

(file-args)=

## File Arguments

Click supports working with files with the {class}`File` type. Some notable features are:

- Support for `-` to mean a special file that refers to stdin when used for reading, and stdout when used for writing.
  This is a common pattern for POSIX command line utilities.
- Deals with `str` and `bytes` correctly for all versions of Python.

Example:

```{eval-rst}
.. click:example::

    @click.command()
    @click.argument('input', type=click.File('rb'))
    @click.argument('output', type=click.File('wb'))
    def inout(input, output):
        """Copy contents of INPUT to OUTPUT."""
        while True:
            chunk = input.read(1024)
            if not chunk:
                break
            output.write(chunk)

And from the command line:

.. click:run::

    with isolated_filesystem():
        invoke(inout, args=['-', 'hello.txt'], input=['hello'],
               terminate_input=True)
        invoke(inout, args=['hello.txt', '-'])
```

## File Path Arguments

For handling paths, the {class}`Path` type is better than a `str`. Some notable features are:

- The `exists` argument will verify whether the path exists.
- `readable`, `writable`, and `executable` can perform permission checks.
- `file_okay` and `dir_okay` allow specifying whether files/directories are accepted.
- Error messages are nicely formatted using {func}`format_filename` so any undecodable bytes will be printed nicely.

See {class}`Path` for all features.

Example:

```{eval-rst}
.. click:example::

    @click.command()
    @click.argument('filename', type=click.Path(exists=True))
    def touch(filename):
        """Print FILENAME if the file exists."""
        click.echo(click.format_filename(filename))

And from the command line:

.. click:run::

    with isolated_filesystem():
        with open('hello.txt', 'w') as f:
            f.write('Hello World!\n')
        invoke(touch, args=['hello.txt'])
        println()
        invoke(touch, args=['missing.txt'])
```

## File Opening Behaviors

The {class}`File` type attempts to be "intelligent" about when to open a file. Stdin/stdout and files opened for reading
will be opened immediately. This will give the user direct feedback when a file cannot be opened. Files opened for
writing will only be open on the first IO operation. This is done by automatically wrapping the file in a special
wrapper.

File open behavior can be controlled by the boolean kwarg `lazy`. If a file is opened lazily:

- A failure at first IO operation will happen by raising an {exc}`FileError`.
- It can help minimize resource handling confusion by lazily closing it. This is not needed for
  parameters, but is necessary for manually prompting. For manual prompts with the {func}`prompt` function you do not
  know if a stream like stdout was opened (which was already open before) or a real file was opened (that needs
  closing).

Since files opened for writing will typically empty the file, the lazy mode should only be disabled if the developer is
absolutely sure that this is intended behavior.

It is also possible to open files in atomic mode by passing `atomic=True`. In atomic mode, all writes go into a separate
file in the same folder, and upon completion, the file will be moved over to the original location. This is useful if a
file regularly read by other users is modified.

//              Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
//   (See accompanying file LICENSE.txt or copy at
//        https://www.boost.org/LICENSE_1_0.txt)

// SPDX-License-Identifier: BSL-1.0

/**\file
 * Checks that test cases with identical name and tags are reported as error
 */

#include <catch2/catch_test_macros.hpp>

TEST_CASE("A test case with duplicated name and tags", "[tag1][tag2]") {}
TEST_CASE("A test case with duplicated name and tags", "[tag1][tag2]") {}

# Security Policy

## Supported versions

The following table describes the versions of this project that are currently
supported with security updates:

| Version | Supported          |
| ------- | ------------------ |
| 4.x   | :white_check_mark:   |
| 3.x   | :x:                  |
| 2.x   | :x:                  |
| 1.x   | :x:                  |

## Threat Model

To better understand which classes of vulnerabilities are considered in-scope or out-of-scope for Lodash, please review the [Lodash Threat Model](./threat-model.md).

The threat model defines Lodash’s trust boundaries and clarifies how security issues are assessed for triage and disclosure.

## Responsible disclosure security policy

A responsible disclosure policy helps protect users of the project from publicly
disclosed security vulnerabilities without a fix by employing a process where
vulnerabilities are first triaged in a private manner, and only publicly disclosed
after a reasonable time period that allows patching the vulnerability and provides
an upgrade path for users.

We kindly ask you to refrain from malicious acts that put our users, the project,
or any of the project’s team members at risk.

## Reporting a security issue

We consider the security of Lodash a top priority. But no matter how much effort
we put into security, there can still be vulnerabilities present.

If you discover a security vulnerability, please report the security issue
directly to the Lodash maintainers through the [Security tab](https://github.com/lodash/lodash/security) of the Lodash
repository.

Your efforts to responsibly disclose your findings are sincerely appreciated.

## Escalation

If you do not receive an acknowledgement of your report within 6 business days, or if you cannot find a private security contact for the project, you may escalate to the OpenJS Foundation CNA at `security@lists.openjsf.org`.

If the project acknowledges your report but does not provide any further response or engagement within 14 days, escalation is also appropriate.

# Supporting Multiple Versions

If you are a library maintainer, you may want to support multiple versions of
Click. See the Pallets [version policy] for information about our version
numbers and support policy.

[version policy]: https://palletsprojects.com/versions

Most features of Click are stable across releases, and don't require special
handling. However, feature releases may deprecate and change APIs. Occasionally,
a change will require special handling.

## Use Feature Detection

Prefer using feature detection. Looking at the version can be tempting, but is
often more brittle or results in more complicated code. Try to use `if` or `try`
blocks to decide whether to use a new or old pattern.

If you do need to look at the version, use {func}`importlib.metadata.version`,
the standardized way to get versions for any installed Python package.

## Changes in 8.2

### `ParamType` methods require `ctx`

In 8.2, several methods of `ParamType` now have a `ctx: click.Context`
argument. Because this changes the signature of the methods from 8.1, it's not
obvious how to support both when subclassing or calling.

This example uses `ParamType.get_metavar`, and the same technique should be
applicable to other methods such as `get_missing_message`.

Update your methods overrides to take the new `ctx` argument. Use the
following decorator to wrap each method. In 8.1, it will get the context where
possible and pass it using the 8.2 signature.

```python
import functools
import typing as t
import click

F = t.TypeVar("F", bound=t.Callable[..., t.Any])

def add_ctx_arg(f: F) -> F:
    @functools.wraps(f)
    def wrapper(*args: t.Any, **kwargs: t.Any) -> t.Any:
        if "ctx" not in kwargs:
            kwargs["ctx"] = click.get_current_context(silent=True)

        return f(*args, **kwargs)

    return wrapper  # type: ignore[return-value]
```

Here's an example ``ParamType`` subclass which uses this:

```python
class CommaDelimitedString(click.ParamType[str]):
    @add_ctx_arg
    def get_metavar(self, param: click.Parameter, ctx: click.Context | None) -> str:
        return "TEXT,TEXT,..."
```

//              Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
//   (See accompanying file LICENSE.txt or copy at
//        https://www.boost.org/LICENSE_1_0.txt)

// SPDX-License-Identifier: BSL-1.0

// 231-Cfg-OutputStreams.cpp
// Show how to replace the streams with a simple custom made streambuf.

// Note that this reimplementation _does not_ follow `std::cerr`
// semantic, because it buffers the output. For most uses however,
// there is no important difference between having `std::cerr` buffered
// or unbuffered.
#include <catch2/catch_test_macros.hpp>

#include <sstream>
#include <cstdio>

class out_buff : public std::stringbuf {
    std::FILE* m_stream;
public:
    out_buff(std::FILE* stream):m_stream(stream) {}
    ~out_buff() override;
    int sync() override {
        int ret = 0;
        for (unsigned char c : str()) {
            if (putc(c, m_stream) == EOF) {
                ret = -1;
                break;
            }
        }
        // Reset the buffer to avoid printing it multiple times
        str("");
        return ret;
    }
};

out_buff::~out_buff() { pubsync(); }

#if defined(__clang__)
#pragma clang diagnostic ignored "-Wexit-time-destructors" // static variables in cout/cerr/clog
#endif

namespace Catch {
    std::ostream& cout() {
        static std::ostream ret(new out_buff(stdout));
        return ret;
    }
    std::ostream& clog() {
        static std::ostream ret(new out_buff(stderr));
        return ret;
    }
    std::ostream& cerr() {
        return clog();
    }
}


TEST_CASE("This binary uses putc to write out output", "[compilation-only]") {
    SUCCEED("Nothing to test.");
}

;(function() {
  'use strict';

  /** Used as a safe reference for `undefined` in pre-ES5 environments. */
  var undefined;

  /** Used as the size to cover large array optimizations. */
  var LARGE_ARRAY_SIZE = 200;

  /** Used as a reference to the global object. */
  var root = (typeof global == 'object' && global) || this;

  /** Used for native method references. */
  var arrayProto = Array.prototype;

  /** Method and object shortcuts. */
  var phantom = root.phantom,
      argv = root.process && process.argv,
      document = !phantom && root.document,
      slice = arrayProto.slice,
      WeakMap = root.WeakMap;

  /** Math helpers. */
  var add = function(x, y) { return x + y; },
      isEven = function(n) { return n % 2 == 0; },
      isEvenIndex = function(n, index) { return isEven(index); },
      square = function(n) { return n * n; };

  // Leak to avoid sporadic `noglobals` fails on Edge in Sauce Labs.
  root.msWDfn = undefined;

  /*--------------------------------------------------------------------------*/

  /** Load QUnit and extras. */
  var QUnit = root.QUnit || require('qunit-extras');

  /** Load stable Lodash. */
  var _ = root._ || require('../lodash.js');

  var convert = (function() {
    var baseConvert = root.fp || require('../fp/_baseConvert.js');
    if (!root.fp) {
      return function(name, func, options) {
        return baseConvert(_, name, func, options);
      };
    }
    return function(name, func, options) {
      if (typeof name == 'function') {
        options = func;
        func = name;
        name = undefined;
      }
      return name === undefined
        ? baseConvert(func, options)
        : baseConvert(_.runInContext(), options)[name];
    };
  }());

  var allFalseOptions = {
    'cap': false,
    'curry': false,
    'fixed': false,
    'immutable': false,
    'rearg': false
  };

  var fp = root.fp
    ? (fp = _.noConflict(), _ = root._, fp)
    : convert(_.runInContext());

  var mapping = root.mapping || require('../fp/_mapping.js');

  /*--------------------------------------------------------------------------*/

  /**
   * Skips a given number of tests with a passing result.
   *
   * @private
   * @param {Object} assert The QUnit assert object.
   * @param {number} [count=1] The number of tests to skip.
   */
  function skipAssert(assert, count) {
    count || (count = 1);
    while (count--) {
      assert.ok(true, 'test skipped');
    }
  }

  /*--------------------------------------------------------------------------*/

  if (argv) {
    console.log('Running lodash/fp tests.');
  }

  QUnit.module('convert module');

  (function() {
    QUnit.test('should work with `name` and `func`', function(assert) {
      assert.expect(2);

      var array = [1, 2, 3, 4],
          remove = convert('remove', _.remove),
          actual = remove(isEven)(array);

      assert.deepEqual(array, [1, 2, 3, 4]);
      assert.deepEqual(actual, [1, 3]);
    });

    QUnit.test('should work with `name`, `func`, and `options`', function(assert) {
      assert.expect(3);

      var array = [1, 2, 3, 4],
          remove = convert('remove', _.remove, allFalseOptions);

      var actual = remove(array, function(n, index) {
        return isEven(index);
      });

      assert.deepEqual(array, [2, 4]);
      assert.deepEqual(actual, [1, 3]);
      assert.deepEqual(remove(), []);
    });

    QUnit.test('should work with an object', function(assert) {
      assert.expect(2);

      if (!document) {
        var array = [1, 2, 3, 4],
            lodash = convert({ 'remove': _.remove }),
            actual = lodash.remove(isEven)(array);

        assert.deepEqual(array, [1, 2, 3, 4]);
        assert.deepEqual(actual, [1, 3]);
      }
      else {
        skipAssert(assert, 2);
      }
    });

    QUnit.test('should work with an object and `options`', function(assert) {
      assert.expect(3);

      if (!document) {
        var array = [1, 2, 3, 4],
            lodash = convert({ 'remove': _.remove }, allFalseOptions),
            actual = lodash.remove(array, isEvenIndex);

        assert.deepEqual(array, [2, 4]);
        assert.deepEqual(actual, [1, 3]);
        assert.deepEqual(lodash.remove(), []);
      }
      else {
        skipAssert(assert, 3);
      }
    });

    QUnit.test('should work with lodash and `options`', function(assert) {
      assert.expect(3);

      var array = [1, 2, 3, 4],
          lodash = convert(_.runInContext(), allFalseOptions),
          actual = lodash.remove(array, isEvenIndex);

      assert.deepEqual(array, [2, 4]);
      assert.deepEqual(actual, [1, 3]);
      assert.deepEqual(lodash.remove(), []);
    });

    QUnit.test('should work with `runInContext` and `options`', function(assert) {
      assert.expect(3);

      var array = [1, 2, 3, 4],
          runInContext = convert('runInContext', _.runInContext, allFalseOptions),
          lodash = runInContext(),
          actual = lodash.remove(array, isEvenIndex);

      assert.deepEqual(array, [2, 4]);
      assert.deepEqual(actual, [1, 3]);
      assert.deepEqual(lodash.remove(), []);
    });

    QUnit.test('should accept a variety of options', function(assert) {
      assert.expect(8);

      var array = [1, 2, 3, 4],
          value = _.clone(array),
          remove = convert('remove', _.remove, { 'cap': false }),
          actual = remove(isEvenIndex)(value);

      assert.deepEqual(value, [1, 2, 3, 4]);
      assert.deepEqual(actual, [2, 4]);

      remove = convert('remove', _.remove, { 'curry': false });
      actual = remove(isEven);

      assert.deepEqual(actual, []);

      var trim = convert('trim', _.trim, { 'fixed': false });
      assert.strictEqual(trim('_-abc-_', '_-'), 'abc');

      value = _.clone(array);
      remove = convert('remove', _.remove, { 'immutable': false });
      actual = remove(isEven)(value);

      assert.deepEqual(value, [1, 3]);
      assert.deepEqual(actual, [2, 4]);

      value = _.clone(array);
      remove = convert('remove', _.remove, { 'rearg': false });
      actual = remove(value)(isEven);

      assert.deepEqual(value, [1, 2, 3, 4]);
      assert.deepEqual(actual, [1, 3]);
    });

    QUnit.test('should respect the `cap` option', function(assert) {
      assert.expect(1);

      var iteratee = convert('iteratee', _.iteratee, { 'cap': false });

      var func = iteratee(function(a, b, c) {
        return [a, b, c];
      }, 3);

      assert.deepEqual(func(1, 2, 3), [1, 2, 3]);
    });

    QUnit.test('should respect the `rearg` option', function(assert) {
      assert.expect(1);

      var add = convert('add', _.add, { 'rearg': true });

      assert.strictEqual(add('2')('1'), '12');
    });

    QUnit.test('should add a `placeholder` property', function(assert) {
      assert.expect(2);

      if (!document) {
        var lodash = convert({ 'add': _.add });

        assert.strictEqual(lodash.placeholder, lodash);
        assert.strictEqual(lodash.add.placeholder, lodash);
      }
      else {
        skipAssert(assert, 2);
      }
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('method.convert');

  (function() {
    QUnit.test('should exist on unconverted methods', function(assert) {
      assert.expect(2);

      var array = [],
          isArray = fp.isArray.convert({ 'curry': true });

      assert.strictEqual(fp.isArray(array), true);
      assert.strictEqual(isArray()(array), true);
    });

    QUnit.test('should convert method aliases', function(assert) {
      assert.expect(1);

      var all = fp.all.convert({ 'rearg': false }),
          actual = all([0])(_.identity);

      assert.strictEqual(actual, false);
    });

    QUnit.test('should convert remapped methods', function(assert) {
      assert.expect(1);

      var extendAll = fp.extendAll.convert({ 'immutable': false }),
          object = {};

      extendAll([object, { 'a': 1 }, { 'b': 2 }]);
      assert.deepEqual(object, { 'a': 1, 'b': 2 });
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('convert methods');

  _.each(['fp.convert', 'method.convert'], function(methodName) {
    var isFp = methodName == 'fp.convert',
        func = isFp ? fp.convert : fp.remove.convert;

    QUnit.test('`' + methodName + '` should work with an object', function(assert) {
      assert.expect(3);

      var array = [1, 2, 3, 4],
          lodash = func(allFalseOptions),
          remove = isFp ? lodash.remove : lodash,
          actual = remove(array, isEvenIndex);

      assert.deepEqual(array, [2, 4]);
      assert.deepEqual(actual, [1, 3]);
      assert.deepEqual(remove(), []);
    });

    QUnit.test('`' + methodName + '` should extend existing configs', function(assert) {
      assert.expect(2);

      var array = [1, 2, 3, 4],
          lodash = func({ 'cap': false }),
          remove = (isFp ? lodash.remove : lodash).convert({ 'rearg': false }),
          actual = remove(array)(isEvenIndex);

      assert.deepEqual(array, [1, 2, 3, 4]);
      assert.deepEqual(actual, [2, 4]);
    });
  });

  /*--------------------------------------------------------------------------*/

  QUnit.module('method arity checks');

  (function() {
    QUnit.test('should wrap methods with an arity > `1`', function(assert) {
      assert.expect(1);

      var methodNames = _.filter(_.functions(fp), function(methodName) {
        return fp[methodName].length > 1;
      });

      assert.deepEqual(methodNames, []);
    });

    QUnit.test('should have >= arity of `aryMethod` designation', function(assert) {
      assert.expect(4);

      _.times(4, function(index) {
        var aryCap = index + 1;

        var methodNames = _.filter(mapping.aryMethod[aryCap], function(methodName) {
          var key = _.get(mapping.remap, methodName, methodName),
              arity = _[key].length;

          return arity != 0 && arity < aryCap;
        });

        assert.deepEqual(methodNames, [], '`aryMethod[' + aryCap + ']`');
      });
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('method aliases');

  (function() {
    QUnit.test('should have correct aliases', function(assert) {
      assert.expect(1);

      var actual = _.transform(mapping.aliasToReal, function(result, realName, alias) {
        result.push([alias, fp[alias] === fp[realName]]);
      }, []);

      assert.deepEqual(_.reject(actual, 1), []);
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('method ary caps');

  (function() {
    QUnit.test('should have a cap of 1', function(assert) {
      assert.expect(1);

      var funcMethods = [
        'curry', 'iteratee', 'memoize', 'over', 'overEvery', 'overSome',
        'method', 'methodOf', 'rest', 'runInContext'
      ];

      var exceptions = funcMethods.concat('mixin', 'nthArg', 'template'),
          expected = _.map(mapping.aryMethod[1], _.constant(true));

      var actual = _.map(mapping.aryMethod[1], function(methodName) {
        var arg = _.includes(funcMethods, methodName) ? _.noop : 1,
            result = _.attempt(function() { return fp[methodName](arg); });

        if (_.includes(exceptions, methodName)
              ? typeof result == 'function'
              : typeof result != 'function'
            ) {
          return true;
        }
        console.log(methodName, result);
        return false;
      });

      assert.deepEqual(actual, expected);
    });

    QUnit.test('should have a cap of 2', function(assert) {
      assert.expect(1);

      var funcMethods = [
        'after', 'ary', 'before', 'bind', 'bindKey', 'curryN', 'debounce',
        'delay', 'overArgs', 'partial', 'partialRight', 'rearg', 'throttle',
        'wrap'
      ];

      var exceptions = _.without(funcMethods.concat('matchesProperty'), 'delay'),
          expected = _.map(mapping.aryMethod[2], _.constant(true));

      var actual = _.map(mapping.aryMethod[2], function(methodName) {
        var args = _.includes(funcMethods, methodName) ? [methodName == 'curryN' ? 1 : _.noop, _.noop] : [1, []],
            result = _.attempt(function() { return fp[methodName](args[0])(args[1]); });

        if (_.includes(exceptions, methodName)
              ? typeof result == 'function'
              : typeof result != 'function'
            ) {
          return true;
        }
        console.log(methodName, result);
        return false;
      });

      assert.deepEqual(actual, expected);
    });

    QUnit.test('should have a cap of 3', function(assert) {
      assert.expect(1);

      var funcMethods = [
        'assignWith', 'extendWith', 'isEqualWith', 'isMatchWith', 'reduce',
        'reduceRight', 'transform', 'zipWith'
      ];

      var expected = _.map(mapping.aryMethod[3], _.constant(true));

      var actual = _.map(mapping.aryMethod[3], function(methodName) {
        var args = _.includes(funcMethods, methodName) ? [_.noop, 0, 1] : [0, 1, []],
            result = _.attempt(function() { return fp[methodName](args[0])(args[1])(args[2]); });

        if (typeof result != 'function') {
          return true;
        }
        console.log(methodName, result);
        return false;
      });

      assert.deepEqual(actual, expected);
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('methods that use `indexOf`');

  (function() {
    QUnit.test('should work with `fp.indexOf`', function(assert) {
      assert.expect(10);

      var array = ['a', 'b', 'c'],
          other = ['b', 'd', 'b'],
          object = { 'a': 1, 'b': 2, 'c': 2 },
          actual = fp.difference(array)(other);

      assert.deepEqual(actual, ['a', 'c'], 'fp.difference');

      actual = fp.includes('b')(array);
      assert.strictEqual(actual, true, 'fp.includes');

      actual = fp.intersection(other)(array);
      assert.deepEqual(actual, ['b'], 'fp.intersection');

      actual = fp.omit(other)(object);
      assert.deepEqual(actual, { 'a': 1, 'c': 2 }, 'fp.omit');

      actual = fp.union(other)(array);
      assert.deepEqual(actual, ['a', 'b', 'c', 'd'], 'fp.union');

      actual = fp.uniq(other);
      assert.deepEqual(actual, ['b', 'd'], 'fp.uniq');

      actual = fp.uniqBy(_.identity, other);
      assert.deepEqual(actual, ['b', 'd'], 'fp.uniqBy');

      actual = fp.without(other)(array);
      assert.deepEqual(actual, ['a', 'c'], 'fp.without');

      actual = fp.xor(other)(array);
      assert.deepEqual(actual, ['a', 'c', 'd'], 'fp.xor');

      actual = fp.pull('b')(array);
      assert.deepEqual(actual, ['a', 'c'], 'fp.pull');
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('cherry-picked methods');

  (function() {
    QUnit.test('should provide the correct `iteratee` arguments', function(assert) {
      assert.expect(4);

      var args,
          array = [1, 2, 3],
          object = { 'a': 1, 'b': 2 },
          isFIFO = _.keys(object)[0] == 'a',
          map = convert('map', _.map),
          reduce = convert('reduce', _.reduce);

      map(function() {
        args || (args = slice.call(arguments));
      })(array);

      assert.deepEqual(args, [1]);

      args = undefined;
      map(function() {
        args || (args = slice.call(arguments));
      })(object);

      assert.deepEqual(args, isFIFO ? [1] : [2]);

      args = undefined;
      reduce(function() {
        args || (args = slice.call(arguments));
      })(0)(array);

      assert.deepEqual(args, [0, 1]);

      args = undefined;
      reduce(function() {
        args || (args = slice.call(arguments));
      })(0)(object);

      assert.deepEqual(args, isFIFO ? [0, 1] : [0, 2]);
    });

    QUnit.test('should not support shortcut fusion', function(assert) {
      assert.expect(3);

      var array = fp.range(0, LARGE_ARRAY_SIZE),
          filterCount = 0,
          mapCount = 0;

      var iteratee = function(value) {
        mapCount++;
        return value * value;
      };

      var predicate = function(value) {
        filterCount++;
        return isEven(value);
      };

      var map1 = convert('map', _.map),
          filter1 = convert('filter', _.filter),
          take1 = convert('take', _.take);

      var filter2 = filter1(predicate),
          map2 = map1(iteratee),
          take2 = take1(2);

      var combined = fp.flow(map2, filter2, fp.compact, take2);

      assert.deepEqual(combined(array), [4, 16]);
      assert.strictEqual(filterCount, 200, 'filterCount');
      assert.strictEqual(mapCount, 200, 'mapCount');
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('iteratee shorthands');

  (function() {
    var objects = [{ 'a': 1, 'b': 2 }, { 'a': 3, 'b': 4 }];

    QUnit.test('should work with "_.matches" shorthands', function(assert) {
      assert.expect(1);

      assert.deepEqual(fp.filter({ 'a': 3 })(objects), [objects[1]]);
    });

    QUnit.test('should work with "_.matchesProperty" shorthands', function(assert) {
      assert.expect(1);

      assert.deepEqual(fp.filter(['a', 3])(objects), [objects[1]]);
    });

    QUnit.test('should work with "_.property" shorthands', function(assert) {
      assert.expect(1);

      assert.deepEqual(fp.map('a')(objects), [1, 3]);
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('placeholder methods');

  (function() {
    QUnit.test('should use `fp` as the default placeholder', function(assert) {
      assert.expect(3);

      var actual = fp.add(fp, 'b')('a');
      assert.strictEqual(actual, 'ab');

      actual = fp.fill(fp, 2)(1, '*')([1, 2, 3]);
      assert.deepEqual(actual, [1, '*', 3]);

      actual = fp.slice(fp, 2)(1)(['a', 'b', 'c']);
      assert.deepEqual(actual, ['b']);
    });

    QUnit.test('should support `fp.placeholder`', function(assert) {
      assert.expect(6);

      _.each([[], fp.__], function(ph) {
        fp.placeholder = ph;

        var actual = fp.add(ph, 'b')('a');
        assert.strictEqual(actual, 'ab');

        actual = fp.fill(ph, 2)(1, '*')([1, 2, 3]);
        assert.deepEqual(actual, [1, '*', 3]);

        actual = fp.slice(ph, 2)(1)(['a', 'b', 'c']);
        assert.deepEqual(actual, ['b']);
      });
    });

    var methodNames = [
      'bind',
      'bindKey',
      'curry',
      'curryRight',
      'partial',
      'partialRight'
    ];

    _.each(methodNames, function(methodName) {
      var func = fp[methodName];

      QUnit.test('fp.' + methodName + '` should have a `placeholder` property', function(assert) {
        assert.expect(2);

        assert.ok(_.isObject(func.placeholder));
        assert.strictEqual(func.placeholder, fp.__);
      });
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('setter methods');

  (function() {
    QUnit.test('should only clone objects in `path`', function(assert) {
      assert.expect(11);

      var object = { 'a': { 'b': 2, 'c': 3 }, 'd': { 'e': 4 } },
          value = _.cloneDeep(object),
          actual = fp.set('a.b.c.d', 5, value);

      assert.ok(_.isObject(actual.a.b), 'fp.set');
      assert.ok(_.isNumber(actual.a.b), 'fp.set');

      assert.strictEqual(actual.a.b.c.d, 5, 'fp.set');
      assert.strictEqual(actual.d, value.d, 'fp.set');

      value = _.cloneDeep(object);
      actual = fp.setWith(Object)('[0][1]')('a')(value);

      assert.deepEqual(actual[0], { '1': 'a' }, 'fp.setWith');

      value = _.cloneDeep(object);
      actual = fp.unset('a.b')(value);

      assert.notOk('b' in actual.a, 'fp.unset');
      assert.strictEqual(actual.a.c, value.a.c, 'fp.unset');

      value = _.cloneDeep(object);
      actual = fp.update('a.b')(square)(value);

      assert.strictEqual(actual.a.b, 4, 'fp.update');
      assert.strictEqual(actual.d, value.d, 'fp.update');

      value = _.cloneDeep(object);
      actual = fp.updateWith(Object)('[0][1]')(_.constant('a'))(value);

      assert.deepEqual(actual[0], { '1': 'a' }, 'fp.updateWith');
      assert.strictEqual(actual.d, value.d, 'fp.updateWith');
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.add and fp.subtract');

  _.each(['add', 'subtract'], function(methodName) {
    var func = fp[methodName],
        isAdd = methodName == 'add';

    QUnit.test('`fp.' + methodName + '` should not have `rearg` applied', function(assert) {
      assert.expect(1);

      assert.strictEqual(func('1')('2'), isAdd ? '12' : -1);
    });
  });

  /*--------------------------------------------------------------------------*/

  QUnit.module('object assignments');

  _.each(['assign', 'assignIn', 'defaults', 'defaultsDeep', 'merge'], function(methodName) {
    var func = fp[methodName];

    QUnit.test('`fp.' + methodName + '` should not mutate values', function(assert) {
      assert.expect(2);

      var object = { 'a': 1 },
          actual = func(object)({ 'b': 2 });

      assert.deepEqual(object, { 'a': 1 });
      assert.deepEqual(actual, { 'a': 1, 'b': 2 });
    });
  });

  _.each(['assignAll', 'assignInAll', 'defaultsAll', 'defaultsDeepAll', 'mergeAll'], function(methodName) {
    var func = fp[methodName];

    QUnit.test('`fp.' + methodName + '` should not mutate values', function(assert) {
      assert.expect(2);

      var objects = [{ 'a': 1 }, { 'b': 2 }],
          actual = func(objects);

      assert.deepEqual(objects[0], { 'a': 1 });
      assert.deepEqual(actual, { 'a': 1, 'b': 2 });
    });
  });

  _.each(['assignWith', 'assignInWith', 'extendWith'], function(methodName) {
    var func = fp[methodName];

    QUnit.test('`fp.' + methodName + '` should provide the correct `customizer` arguments', function(assert) {
      assert.expect(1);

      var args;

      func(function() {
        args || (args = _.map(arguments, _.cloneDeep));
      })({ 'a': 1 })({ 'b': 2 });

      assert.deepEqual(args, [undefined, 2, 'b', { 'a': 1 }, { 'b': 2 }]);
    });
  });

  _.each(['assignAllWith', 'assignInAllWith', 'extendAllWith', 'mergeAllWith'], function(methodName) {
    var func = fp[methodName];

    QUnit.test('`fp.' + methodName + '` should not mutate values', function(assert) {
      assert.expect(2);

      var objects = [{ 'a': 1 }, { 'b': 2 }],
          actual = func(_.noop)(objects);

      assert.deepEqual(objects[0], { 'a': 1 });
      assert.deepEqual(actual, { 'a': 1, 'b': 2 });
    });

    QUnit.test('`fp.' + methodName + '` should work with more than two sources', function(assert) {
      assert.expect(2);

      var pass = false,
          objects = [{ 'a': 1 }, { 'b': 2 }, { 'c': 3 }],
          actual = func(function() { pass = true; })(objects);

      assert.ok(pass);
      assert.deepEqual(actual, { 'a': 1, 'b': 2, 'c': 3 });
    });
  });

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.castArray');

  (function() {
    QUnit.test('should shallow clone array values', function(assert) {
      assert.expect(2);

      var array = [1],
          actual = fp.castArray(array);

      assert.deepEqual(actual, array);
      assert.notStrictEqual(actual, array);
    });

    QUnit.test('should not shallow clone non-array values', function(assert) {
      assert.expect(2);

      var object = { 'a': 1 },
          actual = fp.castArray(object);

      assert.deepEqual(actual, [object]);
      assert.strictEqual(actual[0], object);
    });

    QUnit.test('should convert by name', function(assert) {
      assert.expect(4);

      var array = [1],
          object = { 'a': 1 },
          castArray = convert('castArray', _.castArray),
          actual = castArray(array);

      assert.deepEqual(actual, array);
      assert.notStrictEqual(actual, array);

      actual = castArray(object);
      assert.deepEqual(actual, [object]);
      assert.strictEqual(actual[0], object);
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('curry methods');

  _.each(['curry', 'curryRight'], function(methodName) {
    var func = fp[methodName];

    QUnit.test('fp.' + methodName + '` should only accept a `func` param', function(assert) {
      assert.expect(1);

      assert.raises(function() { func(1, _.noop); }, TypeError);
    });
  });

  /*--------------------------------------------------------------------------*/

  QUnit.module('curryN methods');

  _.each(['curryN', 'curryRightN'], function(methodName) {
    var func = fp[methodName];

    QUnit.test('fp.' + methodName + '` should accept an `arity` param', function(assert) {
      assert.expect(1);

      var actual = func(1)(function(a, b) { return [a, b]; })('a');
      assert.deepEqual(actual, ['a', undefined]);
    });
  });

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.defaultTo');

  (function() {
    QUnit.test('should have an argument order of `defaultValue` then `value`', function(assert) {
      assert.expect(2);

      assert.strictEqual(fp.defaultTo(1)(0), 0);
      assert.strictEqual(fp.defaultTo(1)(undefined), 1);
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.difference');

  (function() {
    QUnit.test('should return the elements of the first array not included in the second array', function(assert) {
      assert.expect(1);

      var actual = fp.difference([2, 1], [2, 3]);
      assert.deepEqual(actual, [1]);
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.differenceBy');

  (function() {
    QUnit.test('should have an argument order of `iteratee`, `array`, then `values`', function(assert) {
      assert.expect(1);

      var actual = fp.differenceBy(Math.floor, [2.1, 1.2], [2.3, 3.4]);
      assert.deepEqual(actual, [1.2]);
    });

    QUnit.test('should provide the correct `iteratee` arguments', function(assert) {
      assert.expect(1);

      var args;

      fp.differenceBy(function() {
        args || (args = slice.call(arguments));
      })([2.1, 1.2], [2.3, 3.4]);

      assert.deepEqual(args, [2.3]);
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.differenceWith');

  (function() {
    QUnit.test('should have an argument order of `comparator`, `array`, then `values`', function(assert) {
      assert.expect(1);

      var actual = fp.differenceWith(fp.eq)([2, 1])([2, 3]);
      assert.deepEqual(actual, [1]);
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.divide and fp.multiply');

  _.each(['divide', 'multiply'], function(methodName) {
    var func = fp[methodName],
        isDivide = methodName == 'divide';

    QUnit.test('`fp.' + methodName + '` should not have `rearg` applied', function(assert) {
      assert.expect(1);

      assert.strictEqual(func('2')('4'), isDivide ? 0.5 : 8);
    });
  });

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.extend');

  (function() {
    QUnit.test('should convert by name', function(assert) {
      assert.expect(2);

      function Foo() {}
      Foo.prototype = { 'b': 2 };

      var object = { 'a': 1 },
          extend = convert('extend', _.extend),
          actual = extend(object)(new Foo);

      assert.deepEqual(object, { 'a': 1 });
      assert.deepEqual(actual, { 'a': 1, 'b': 2 });
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.fill');

  (function() {
    QUnit.test('should have an argument order of `start`, `end`, then `value`', function(assert) {
      assert.expect(1);

      var array = [1, 2, 3];
      assert.deepEqual(fp.fill(1)(2)('*')(array), [1, '*', 3]);
    });

    QUnit.test('should not mutate values', function(assert) {
      assert.expect(2);

      var array = [1, 2, 3],
          actual = fp.fill(1)(2)('*')(array);

      assert.deepEqual(array, [1, 2, 3]);
      assert.deepEqual(actual, [1, '*', 3]);
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.findFrom methods');

  _.each(['findFrom', 'findIndexFrom', 'findLastFrom', 'findLastIndexFrom'], function(methodName) {
    var func = fp[methodName];

    QUnit.test('fp.' + methodName + '` should provide the correct `predicate` arguments', function(assert) {
      assert.expect(1);

      var args;

      func(function() {
        args || (args = slice.call(arguments));
      })(1)([1, 2, 3]);

      assert.deepEqual(args, [2]);
    });
  });

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.findFrom');

  (function() {
    function resolve(value) {
      return fp.flow(fp.property('a'), fp.eq(value));
    }

    QUnit.test('should have an argument order of `value`, `fromIndex`, then `array`', function(assert) {
      assert.expect(2);

      var objects = [{ 'a': 1 }, { 'a': 2 }, { 'a': 1 }, { 'a': 2 }];

      assert.strictEqual(fp.findFrom(resolve(1))(1)(objects), objects[2]);
      assert.strictEqual(fp.findFrom(resolve(2))(-2)(objects), objects[3]);
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.findLastFrom');

  (function() {
    function resolve(value) {
      return fp.flow(fp.property('a'), fp.eq(value));
    }

    QUnit.test('should have an argument order of `value`, `fromIndex`, then `array`', function(assert) {
      assert.expect(2);

      var objects = [{ 'a': 1 }, { 'a': 2 }, { 'a': 1 }, { 'a': 2 }];

      assert.strictEqual(fp.findLastFrom(resolve(1))(1)(objects), objects[0]);
      assert.strictEqual(fp.findLastFrom(resolve(2))(-2)(objects), objects[1]);
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.findIndexFrom and fp.indexOfFrom');

  _.each(['findIndexFrom', 'indexOfFrom'], function(methodName) {
    var func = fp[methodName],
        resolve = methodName == 'findIndexFrom' ? fp.eq : _.identity;

    QUnit.test('fp.' + methodName + '` should have an argument order of `value`, `fromIndex`, then `array`', function(assert) {
      assert.expect(2);

      var array = [1, 2, 3, 1, 2, 3];

      assert.strictEqual(func(resolve(1))(2)(array), 3);
      assert.strictEqual(func(resolve(2))(-3)(array), 4);
    });
  });

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.findLastIndexFrom and fp.lastIndexOfFrom');

  _.each(['findLastIndexFrom', 'lastIndexOfFrom'], function(methodName) {
    var func = fp[methodName],
        resolve = methodName == 'findLastIndexFrom' ? fp.eq : _.identity;

    QUnit.test('fp.' + methodName + '` should have an argument order of `value`, `fromIndex`, then `array`', function(assert) {
      assert.expect(2);

      var array = [1, 2, 3, 1, 2, 3];

      assert.strictEqual(func(resolve(2))(3)(array), 1);
      assert.strictEqual(func(resolve(3))(-3)(array), 2);
    });
  });

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.flatMapDepth');

  (function() {
    QUnit.test('should have an argument order of `iteratee`, `depth`, then `collection`', function(assert) {
      assert.expect(2);

      function duplicate(n) {
        return [[[n, n]]];
      }

      var array = [1, 2],
          object = { 'a': 1, 'b': 2 },
          expected = [[1, 1], [2, 2]];

      assert.deepEqual(fp.flatMapDepth(duplicate)(2)(array), expected);
      assert.deepEqual(fp.flatMapDepth(duplicate)(2)(object), expected);
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('flow methods');

  _.each(['flow', 'flowRight'], function(methodName) {
    var func = fp[methodName],
        isFlow = methodName == 'flow';

    QUnit.test('`fp.' + methodName + '` should support shortcut fusion', function(assert) {
      assert.expect(6);

      var filterCount,
          mapCount,
          array = fp.range(0, LARGE_ARRAY_SIZE);

      var iteratee = function(value) {
        mapCount++;
        return square(value);
      };

      var predicate = function(value) {
        filterCount++;
        return isEven(value);
      };

      var filter = fp.filter(predicate),
          map = fp.map(iteratee),
          take = fp.take(2);

      _.times(2, function(index) {
        var combined = isFlow
          ? func(map, filter, fp.compact, take)
          : func(take, fp.compact, filter, map);

        filterCount = mapCount = 0;

        if (WeakMap && WeakMap.name) {
          assert.deepEqual(combined(array), [4, 16]);
          assert.strictEqual(filterCount, 5, 'filterCount');
          assert.strictEqual(mapCount, 5, 'mapCount');
        }
        else {
          skipAssert(assert, 3);
        }
      });
    });
  });

  /*--------------------------------------------------------------------------*/

  QUnit.module('forEach methods');

  _.each(['forEach', 'forEachRight', 'forIn', 'forInRight', 'forOwn', 'forOwnRight'], function(methodName) {
    var func = fp[methodName];

    QUnit.test('`fp.' + methodName + '` should provide `value` to `iteratee`', function(assert) {
      assert.expect(2);

      var args;

      func(function() {
        args || (args = slice.call(arguments));
      })(['a']);

      assert.deepEqual(args, ['a']);

      args = undefined;

      func(function() {
        args || (args = slice.call(arguments));
      })({ 'a': 1 });

      assert.deepEqual(args, [1]);
    });
  });

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.getOr');

  (function() {
    QUnit.test('should accept a `defaultValue` param', function(assert) {
      assert.expect(1);

      var actual = fp.getOr('default')('path')({});
      assert.strictEqual(actual, 'default');
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.gt and fp.gte');

  _.each(['gt', 'gte'], function(methodName) {
    var func = fp[methodName];

    QUnit.test('`fp.' + methodName + '` should have `rearg` applied', function(assert) {
      assert.expect(1);

      assert.strictEqual(func(2)(1), true);
    });
  });

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.inRange');

  (function() {
    QUnit.test('should have an argument order of `start`, `end`, then `value`', function(assert) {
      assert.expect(2);

      assert.strictEqual(fp.inRange(2)(4)(3), true);
      assert.strictEqual(fp.inRange(-2)(-6)(-3), true);
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.intersectionBy');

  (function() {
    QUnit.test('should have an argument order of `iteratee`, `array`, then `values`', function(assert) {
      assert.expect(1);

      var actual = fp.intersectionBy(Math.floor, [2.1, 1.2], [2.3, 3.4]);
      assert.deepEqual(actual, [2.1]);
    });

    QUnit.test('should provide the correct `iteratee` arguments', function(assert) {
      assert.expect(1);

      var args;

      fp.intersectionBy(function() {
        args || (args = slice.call(arguments));
      })([2.1, 1.2], [2.3, 3.4]);

      assert.deepEqual(args, [2.3]);
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.intersectionWith');

  (function() {
    QUnit.test('should have an argument order of `comparator`, `array`, then `values`', function(assert) {
      assert.expect(1);

      var actual = fp.intersectionWith(fp.eq)([2, 1])([2, 3]);
      assert.deepEqual(actual, [2]);
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.invoke');

  (function() {
    QUnit.test('should not accept an `args` param', function(assert) {
      assert.expect(1);

      var actual = fp.invoke('toUpperCase')('a');
      assert.strictEqual(actual, 'A');
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.invokeMap');

  (function() {
    QUnit.test('should not accept an `args` param', function(assert) {
      assert.expect(1);

      var actual = fp.invokeMap('toUpperCase')(['a', 'b']);
      assert.deepEqual(actual, ['A', 'B']);
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.invokeArgs');

  (function() {
    QUnit.test('should accept an `args` param', function(assert) {
      assert.expect(1);

      var actual = fp.invokeArgs('concat')(['b', 'c'])('a');
      assert.strictEqual(actual, 'abc');
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.invokeArgsMap');

  (function() {
    QUnit.test('should accept an `args` param', function(assert) {
      assert.expect(1);

      var actual = fp.invokeArgsMap('concat')(['b', 'c'])(['a', 'A']);
      assert.deepEqual(actual, ['abc', 'Abc']);
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.isEqualWith');

  (function() {
    QUnit.test('should provide the correct `customizer` arguments', function(assert) {
      assert.expect(1);

      var args,
          iteration = 0,
          objects = [{ 'a': 1 }, { 'a': 2 }],
          stack = { '__data__': { '__data__': [objects, objects.slice().reverse()], 'size': 2 }, 'size': 2 },
          expected = [1, 2, 'a', objects[0], objects[1], stack];

      fp.isEqualWith(function() {
        if (++iteration == 2) {
          args = _.map(arguments, _.cloneDeep);
        }
      })(objects[0])(objects[1]);

      args[5] = _.omitBy(args[5], _.isFunction);
      args[5].__data__ = _.omitBy(args[5].__data__, _.isFunction);

      assert.deepEqual(args, expected);
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.isMatchWith');

  (function() {
    QUnit.test('should provide the correct `customizer` arguments', function(assert) {
      assert.expect(1);

      var args,
          objects = [{ 'a': 1 }, { 'a': 2 }],
          stack = { '__data__': { '__data__': [], 'size': 0 }, 'size': 0 },
          expected = [2, 1, 'a', objects[1], objects[0], stack];

      fp.isMatchWith(function() {
        args || (args = _.map(arguments, _.cloneDeep));
      })(objects[0])(objects[1]);

      args[5] = _.omitBy(args[5], _.isFunction);
      args[5].__data__ = _.omitBy(args[5].__data__, _.isFunction);

      assert.deepEqual(args, expected);
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.iteratee');

  (function() {
    QUnit.test('should return a iteratee with capped params', function(assert) {
      assert.expect(1);

      var func = fp.iteratee(function(a, b, c) { return [a, b, c]; }, 3);
      assert.deepEqual(func(1, 2, 3), [1, undefined, undefined]);
    });

    QUnit.test('should convert by name', function(assert) {
      assert.expect(1);

      var iteratee = convert('iteratee', _.iteratee),
          func = iteratee(function(a, b, c) { return [a, b, c]; }, 3);

      assert.deepEqual(func(1, 2, 3), [1, undefined, undefined]);
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.lt and fp.lte');

  _.each(['lt', 'lte'], function(methodName) {
    var func = fp[methodName];

    QUnit.test('`fp.' + methodName + '` should have `rearg` applied', function(assert) {
      assert.expect(1);

      assert.strictEqual(func(1)(2), true);
    });
  });

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.mapKeys');

  (function() {
    QUnit.test('should only provide `key` to `iteratee`', function(assert) {
      assert.expect(1);

      var args;

      fp.mapKeys(function() {
        args || (args = slice.call(arguments));
      }, { 'a': 1 });

      assert.deepEqual(args, ['a']);
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.maxBy and fp.minBy');

  _.each(['maxBy', 'minBy'], function(methodName) {
    var array = [1, 2, 3],
        func = fp[methodName],
        isMax = methodName == 'maxBy';

    QUnit.test('`fp.' + methodName + '` should work with an `iteratee` argument', function(assert) {
      assert.expect(1);

      var actual = func(function(num) {
        return -num;
      })(array);

      assert.strictEqual(actual, isMax ? 1 : 3);
    });

    QUnit.test('`fp.' + methodName + '` should provide the correct `iteratee` arguments', function(assert) {
      assert.expect(1);

      var args;

      func(function() {
        args || (args = slice.call(arguments));
      })(array);

      assert.deepEqual(args, [1]);
    });
  });

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.mergeWith');

  (function() {
    QUnit.test('should provide the correct `customizer` arguments', function(assert) {
      assert.expect(1);

      var args,
          stack = { '__data__': { '__data__': [], 'size': 0 }, 'size': 0 },
          expected = [[1, 2], [3], 'a', { 'a': [1, 2] }, { 'a': [3] }, stack];

      fp.mergeWith(function() {
        args || (args = _.map(arguments, _.cloneDeep));
      })({ 'a': [1, 2] })({ 'a': [3] });

      args[5] = _.omitBy(args[5], _.isFunction);
      args[5].__data__ = _.omitBy(args[5].__data__, _.isFunction);

      assert.deepEqual(args, expected);
    });

    QUnit.test('should not mutate values', function(assert) {
      assert.expect(2);

      var objects = [{ 'a': [1, 2] }, { 'a': [3] }],
          actual = fp.mergeWith(_.noop, objects[0], objects[1]);

      assert.deepEqual(objects[0], { 'a': [1, 2] });
      assert.deepEqual(actual, { 'a': [3, 2] });
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.mergeAllWith');

  (function() {
    QUnit.test('should provide the correct `customizer` arguments', function(assert) {
      assert.expect(1);

      var args,
          objects = [{ 'a': [1, 2] }, { 'a': [3] }],
          stack = { '__data__': { '__data__': [], 'size': 0 }, 'size': 0 },
          expected = [[1, 2], [3], 'a', { 'a': [1, 2] }, { 'a': [3] }, stack];

      fp.mergeAllWith(function() {
        args || (args = _.map(arguments, _.cloneDeep));
      })(objects);

      args[5] = _.omitBy(args[5], _.isFunction);
      args[5].__data__ = _.omitBy(args[5].__data__, _.isFunction);

      assert.deepEqual(args, expected);
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.mixin');

  (function() {
    var source = { 'a': _.noop };

    QUnit.test('should mixin static methods but not prototype methods', function(assert) {
      assert.expect(2);

      fp.mixin(source);

      assert.strictEqual(typeof fp.a, 'function');
      assert.notOk('a' in fp.prototype);

      delete fp.a;
      delete fp.prototype.a;
    });

    QUnit.test('should not assign inherited `source` methods', function(assert) {
      assert.expect(2);

      function Foo() {}
      Foo.prototype.a = _.noop;
      fp.mixin(new Foo);

      assert.notOk('a' in fp);
      assert.notOk('a' in fp.prototype);

      delete fp.a;
      delete fp.prototype.a;
    });

    QUnit.test('should not remove existing prototype methods', function(assert) {
      assert.expect(2);

      var each1 = fp.each,
          each2 = fp.prototype.each;

      fp.mixin({ 'each': source.a });

      assert.strictEqual(fp.each, source.a);
      assert.strictEqual(fp.prototype.each, each2);

      fp.each = each1;
      fp.prototype.each = each2;
    });

    QUnit.test('should not export to the global when `source` is not an object', function(assert) {
      assert.expect(2);

      var props = _.without(_.keys(_), '_');

      _.times(2, function(index) {
        fp.mixin.apply(fp, index ? [1] : []);

        assert.ok(_.every(props, function(key) {
          return root[key] !== fp[key];
        }));

        _.each(props, function(key) {
          if (root[key] === fp[key]) {
            delete root[key];
          }
        });
      });
    });

    QUnit.test('should convert by name', function(assert) {
      assert.expect(3);

      var object = { 'mixin': convert('mixin', _.mixin) };

      function Foo() {}
      Foo.mixin = object.mixin;
      Foo.mixin(source);

      assert.ok('a' in Foo);
      assert.notOk('a' in Foo.prototype);

      object.mixin(source);
      assert.ok('a' in object);
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.nthArg');

  (function() {
    QUnit.test('should return a curried function', function(assert) {
      assert.expect(2);

      var func = fp.nthArg(1);
      assert.strictEqual(func(1)(2), 2);

      func = fp.nthArg(-1);
      assert.strictEqual(func(1), 1);
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.over');

  (function() {
    QUnit.test('should not cap iteratee args', function(assert) {
      assert.expect(2);

      _.each([fp.over, convert('over', _.over)], function(func) {
        var over = func([Math.max, Math.min]);
        assert.deepEqual(over(1, 2, 3, 4), [4, 1]);
      });
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.omitBy and fp.pickBy');

  _.each(['omitBy', 'pickBy'], function(methodName) {
    var func = fp[methodName];

    QUnit.test('`fp.' + methodName + '` should provide `value` and `key` to `iteratee`', function(assert) {
      assert.expect(1);

      var args;

      func(function() {
        args || (args = slice.call(arguments));
      })({ 'a': 1 });

      assert.deepEqual(args, [1, 'a']);
    });
  });

  /*--------------------------------------------------------------------------*/

  QUnit.module('padChars methods');

  _.each(['padChars', 'padCharsStart', 'padCharsEnd'], function(methodName) {
    var func = fp[methodName],
        isPad = methodName == 'padChars',
        isStart = methodName == 'padCharsStart';

    QUnit.test('fp.' + methodName + '` should truncate pad characters to fit the pad length', function(assert) {
      assert.expect(1);

      if (isPad) {
        assert.strictEqual(func('_-')(8)('abc'), '_-abc_-_');
      } else {
        assert.strictEqual(func('_-')(6)('abc'), isStart ? '_-_abc' : 'abc_-_');
      }
    });
  });

  /*--------------------------------------------------------------------------*/

  QUnit.module('partial methods');

  _.each(['partial', 'partialRight'], function(methodName) {
    var func = fp[methodName],
        isPartial = methodName == 'partial';

    QUnit.test('fp.' + methodName + '` should accept an `args` param', function(assert) {
      assert.expect(1);

      var expected = isPartial ? [1, 2, 3] : [0, 1, 2];

      var actual = func(function(a, b, c) {
        return [a, b, c];
      })([1, 2])(isPartial ? 3 : 0);

      assert.deepEqual(actual, expected);
    });

    QUnit.test('fp.' + methodName + '` should convert by name', function(assert) {
      assert.expect(2);

      var expected = isPartial ? [1, 2, 3] : [0, 1, 2],
          par = convert(methodName, _[methodName]),
          ph = par.placeholder;

      var actual = par(function(a, b, c) {
        return [a, b, c];
      })([1, 2])(isPartial ? 3 : 0);

      assert.deepEqual(actual, expected);

      actual = par(function(a, b, c) {
        return [a, b, c];
      })([ph, 2])(isPartial ? 1 : 0, isPartial ? 3 : 1);

      assert.deepEqual(actual, expected);
    });
  });

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.propertyOf');

  (function() {
    QUnit.test('should be curried', function(assert) {
      assert.expect(2);

      var object = { 'a': 1 };

      assert.strictEqual(fp.propertyOf(object, 'a'), 1);
      assert.strictEqual(fp.propertyOf(object)('a'), 1);
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.pull');

  (function() {
    QUnit.test('should not mutate values', function(assert) {
      assert.expect(2);

      var array = [1, 2, 3],
          actual = fp.pull(2)(array);

      assert.deepEqual(array, [1, 2, 3]);
      assert.deepEqual(actual, [1, 3]);
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.pullAll');

  (function() {
    QUnit.test('should not mutate values', function(assert) {
      assert.expect(2);

      var array = [1, 2, 3],
          actual = fp.pullAll([1, 3])(array);

      assert.deepEqual(array, [1, 2, 3]);
      assert.deepEqual(actual, [2]);
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.pullAt');

  (function() {
    QUnit.test('should not mutate values', function(assert) {
      assert.expect(2);

      var array = [1, 2, 3],
          actual = fp.pullAt([0, 2])(array);

      assert.deepEqual(array, [1, 2, 3]);
      assert.deepEqual(actual, [2]);
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.random');

  (function() {
    var array = Array(1000);

    QUnit.test('should support a `min` and `max` argument', function(assert) {
      assert.expect(1);

      var min = 5,
          max = 10;

      assert.ok(_.some(array, function() {
        var result = fp.random(min)(max);
        return result >= min && result <= max;
      }));
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('range methods');

  _.each(['range', 'rangeRight'], function(methodName) {
    var func = fp[methodName],
        isRange = methodName == 'range';

    QUnit.test('fp.' + methodName + '` should have an argument order of `start` then `end`', function(assert) {
      assert.expect(1);

      assert.deepEqual(func(1)(4), isRange ? [1, 2, 3] : [3, 2, 1]);
    });
  });

  /*--------------------------------------------------------------------------*/

  QUnit.module('rangeStep methods');

  _.each(['rangeStep', 'rangeStepRight'], function(methodName) {
    var func = fp[methodName],
        isRange = methodName == 'rangeStep';

    QUnit.test('fp.' + methodName + '` should have an argument order of `step`, `start`, then `end`', function(assert) {
      assert.expect(1);

      assert.deepEqual(func(2)(1)(4), isRange ? [1, 3] : [3, 1]);
    });
  });

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.rearg');

  (function() {
    function fn(a, b, c) {
      return [a, b, c];
    }

    QUnit.test('should be curried', function(assert) {
      assert.expect(1);

      var rearged = fp.rearg([1, 2, 0])(fn);
      assert.deepEqual(rearged('c', 'a', 'b'), ['a', 'b', 'c']);
    });

    QUnit.test('should return a curried function', function(assert) {
      assert.expect(1);

      var rearged = fp.rearg([1, 2, 0], fn);
      assert.deepEqual(rearged('c')('a')('b'), ['a', 'b', 'c']);
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('reduce methods');

  _.each(['reduce', 'reduceRight'], function(methodName) {
    var func = fp[methodName],
        isReduce = methodName == 'reduce';

    QUnit.test('`fp.' + methodName + '` should provide the correct `iteratee` arguments when iterating an array', function(assert) {
      assert.expect(1);

      var args;

      func(function() {
        args || (args = slice.call(arguments));
      })(0)([1, 2, 3]);

      assert.deepEqual(args, isReduce ? [0, 1] : [3, 0]);
    });

    QUnit.test('`fp.' + methodName + '` should provide the correct `iteratee` arguments when iterating an object', function(assert) {
      assert.expect(1);

      var args,
          object = { 'a': 1, 'b': 2 },
          isFIFO = _.keys(object)[0] == 'a';

      var expected = isFIFO
        ? (isReduce ? [0, 1] : [2, 0])
        : (isReduce ? [0, 2] : [1, 0]);

      func(function() {
        args || (args = slice.call(arguments));
      })(0)(object);

      assert.deepEqual(args, expected);
    });
  });

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.remove');

  (function() {
    QUnit.test('should not mutate values', function(assert) {
      assert.expect(2);

      var array = [1, 2, 3],
          actual = fp.remove(fp.eq(2))(array);

      assert.deepEqual(array, [1, 2, 3]);
      assert.deepEqual(actual, [1, 3]);
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.restFrom');

  (function() {
    QUnit.test('should accept a `start` param', function(assert) {
      assert.expect(1);

      var actual = fp.restFrom(2)(function() {
        return slice.call(arguments);
      })('a', 'b', 'c', 'd');

      assert.deepEqual(actual, ['a', 'b', ['c', 'd']]);
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.reverse');

  (function() {
    QUnit.test('should not mutate values', function(assert) {
      assert.expect(2);

      var array = [1, 2, 3],
          actual = fp.reverse(array);

      assert.deepEqual(array, [1, 2, 3]);
      assert.deepEqual(actual, [3, 2, 1]);
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.runInContext');

  (function() {
    QUnit.test('should return a converted lodash instance', function(assert) {
      assert.expect(1);

      assert.strictEqual(typeof fp.runInContext({}).curryN, 'function');
    });

    QUnit.test('should convert by name', function(assert) {
      assert.expect(1);

      var runInContext = convert('runInContext', _.runInContext);
      assert.strictEqual(typeof runInContext({}).curryN, 'function');
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.set');

  (function() {
    QUnit.test('should not mutate values', function(assert) {
      assert.expect(2);

      var object = { 'a': { 'b': 2, 'c': 3 } },
          actual = fp.set('a.b')(3)(object);

      assert.deepEqual(object, { 'a': { 'b': 2, 'c': 3 } });
      assert.deepEqual(actual, { 'a': { 'b': 3, 'c': 3 } });
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.setWith');

  (function() {
    QUnit.test('should provide the correct `customizer` arguments', function(assert) {
      assert.expect(1);

      var args;

      fp.setWith(function() {
        args || (args = _.map(arguments, _.cloneDeep));
      })('b.c')(2)({ 'a': 1 });

      assert.deepEqual(args, [undefined, 'b', { 'a': 1 }]);
    });

    QUnit.test('should not mutate values', function(assert) {
      assert.expect(2);

      var object = { 'a': { 'b': 2, 'c': 3 } },
          actual = fp.setWith(Object)('d.e')(4)(object);

      assert.deepEqual(object, { 'a': { 'b': 2, 'c': 3 } });
      assert.deepEqual(actual, { 'a': { 'b': 2, 'c': 3 }, 'd': { 'e': 4 } });
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.spreadFrom');

  (function() {
    QUnit.test('should accept a `start` param', function(assert) {
      assert.expect(1);

      var actual = fp.spreadFrom(2)(function() {
        return slice.call(arguments);
      })('a', 'b', ['c', 'd']);

      assert.deepEqual(actual, ['a', 'b', 'c', 'd']);
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('trimChars methods');

  _.each(['trimChars', 'trimCharsStart', 'trimCharsEnd'], function(methodName, index) {
    var func = fp[methodName],
        parts = [];

    if (index != 2) {
      parts.push('leading');
    }
    if (index != 1) {
      parts.push('trailing');
    }
    parts = parts.join(' and ');

    QUnit.test('`fp.' + methodName + '` should remove ' + parts + ' `chars`', function(assert) {
      assert.expect(1);

      var string = '-_-a-b-c-_-',
          expected = (index == 2 ? '-_-' : '') + 'a-b-c' + (index == 1 ? '-_-' : '');

      assert.strictEqual(func('_-')(string), expected);
    });
  });

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.unionBy');

  (function() {
    QUnit.test('should have an argument order of `iteratee`, `array`, then `other`', function(assert) {
      assert.expect(1);

      var actual = fp.unionBy(Math.floor, [2.1], [1.2, 2.3]);
      assert.deepEqual(actual, [2.1, 1.2]);
    });

    QUnit.test('should provide the correct `iteratee` arguments', function(assert) {
      assert.expect(1);

      var args;

      fp.unionBy(function() {
        args || (args = slice.call(arguments));
      })([2.1], [1.2, 2.3]);

      assert.deepEqual(args, [2.1]);
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.unionWith');

  (function() {
    QUnit.test('should have an argument order of `comparator`, `array`, then `values`', function(assert) {
      assert.expect(1);

      var actual = fp.unionWith(fp.eq)([2, 1])([2, 3]);
      assert.deepEqual(actual, [2, 1, 3]);
    });

    QUnit.test('should provide the correct `comparator` arguments', function(assert) {
      assert.expect(1);

      var args;

      fp.unionWith(function() {
        args || (args = slice.call(arguments));
      })([2, 1])([2, 3]);

      assert.deepEqual(args, [1, 2]);
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.uniqBy');

  (function() {
    var objects = [{ 'a': 2 }, { 'a': 3 }, { 'a': 1 }, { 'a': 2 }, { 'a': 3 }, { 'a': 1 }];

    QUnit.test('should work with an `iteratee` argument', function(assert) {
      assert.expect(1);

      var expected = objects.slice(0, 3),
          actual = fp.uniqBy(_.property('a'))(objects);

      assert.deepEqual(actual, expected);
    });

    QUnit.test('should provide the correct `iteratee` arguments', function(assert) {
      assert.expect(1);

      var args;

      fp.uniqBy(function() {
        args || (args = slice.call(arguments));
      })(objects);

      assert.deepEqual(args, [objects[0]]);
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.uniqWith');

  (function() {
    QUnit.test('should have an argument order of `comparator`, `array`, then `values`', function(assert) {
      assert.expect(1);

      var actual = fp.uniqWith(fp.eq)([2, 1, 2]);
      assert.deepEqual(actual, [2, 1]);
    });

    QUnit.test('should provide the correct `comparator` arguments', function(assert) {
      assert.expect(1);

      var args;

      fp.uniqWith(function() {
        args || (args = slice.call(arguments));
      })([2, 1, 2]);

      assert.deepEqual(args, [1, 2]);
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.update');

  (function() {
    QUnit.test('should not convert end of `path` to an object', function(assert) {
      assert.expect(1);

      var actual = fp.update('a.b')(_.identity)({ 'a': { 'b': 1 } });
      assert.strictEqual(typeof actual.a.b, 'number');
    });

    QUnit.test('should not convert uncloneables to objects', function(assert) {
      assert.expect(2);

      var object = { 'a': { 'b': _.constant(true) } },
          actual = fp.update('a.b')(_.identity)(object);

      assert.strictEqual(typeof object.a.b, 'function');
      assert.strictEqual(object.a.b, actual.a.b);
    });

    QUnit.test('should not mutate values', function(assert) {
      assert.expect(2);

      var object = { 'a': { 'b': 2, 'c': 3 } },
          actual = fp.update('a.b')(square)(object);

      assert.deepEqual(object, { 'a': { 'b': 2, 'c': 3 } });
      assert.deepEqual(actual, { 'a': { 'b': 4, 'c': 3 } });
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.updateWith');

  (function() {
    QUnit.test('should provide the correct `customizer` arguments', function(assert) {
      var args;

      fp.updateWith(function() {
        args || (args = _.map(arguments, _.cloneDeep));
      })('b.c')(_.constant(2))({ 'a': 1 });

      assert.deepEqual(args, [undefined, 'b', { 'a': 1 }]);
    });

    QUnit.test('should not mutate values', function(assert) {
      assert.expect(2);

      var object = { 'a': { 'b': 2, 'c': 3 } },
          actual = fp.updateWith(Object)('d.e')(_.constant(4))(object);

      assert.deepEqual(object, { 'a': { 'b': 2, 'c': 3 } });
      assert.deepEqual(actual, { 'a': { 'b': 2, 'c': 3 }, 'd': { 'e': 4 } });
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.unset');

  (function() {
    QUnit.test('should not mutate values', function(assert) {
      assert.expect(2);

      var object = { 'a': { 'b': 2, 'c': 3 } },
          actual = fp.unset('a.b')(object);

      assert.deepEqual(object, { 'a': { 'b': 2, 'c': 3 } });
      assert.deepEqual(actual, { 'a': { 'c': 3 } });
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.xorBy');

  (function() {
    QUnit.test('should have an argument order of `iteratee`, `array`, then `other`', function(assert) {
      assert.expect(1);

      var actual = fp.xorBy(Math.floor, [2.1, 1.2], [2.3, 3.4]);
      assert.deepEqual(actual, [1.2, 3.4]);
    });

    QUnit.test('should provide the correct `iteratee` arguments', function(assert) {
      assert.expect(1);

      var args;

      fp.xorBy(function() {
        args || (args = slice.call(arguments));
      })([2.1, 1.2], [2.3, 3.4]);

      assert.deepEqual(args, [2.3]);
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.xorWith');

  (function() {
    QUnit.test('should have an argument order of `comparator`, `array`, then `values`', function(assert) {
      assert.expect(1);

      var actual = fp.xorWith(fp.eq)([2, 1])([2, 3]);
      assert.deepEqual(actual, [1, 3]);
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('with methods');

  _.each(['differenceWith', 'intersectionWith', 'xorWith'], function(methodName) {
    var func = fp[methodName];

    QUnit.test('`fp.' + methodName + '` should provide the correct `comparator` arguments', function(assert) {
      assert.expect(1);

      var args;

      func(function() {
        args || (args = slice.call(arguments));
      })([2, 1])([2, 3]);

      assert.deepEqual(args, [2, 2]);
    });
  });

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.zip');

  (function() {
    QUnit.test('should zip together two arrays', function(assert) {
      assert.expect(1);

      assert.deepEqual(fp.zip([1, 2])([3, 4]), [[1, 3], [2, 4]]);
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.zipAll');

  (function() {
    QUnit.test('should zip together an array of arrays', function(assert) {
      assert.expect(1);

      assert.deepEqual(fp.zipAll([[1, 2], [3, 4], [5, 6]]), [[1, 3, 5], [2, 4, 6]]);
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.zipObject');

  (function() {
    QUnit.test('should zip together key/value arrays into an object', function(assert) {
      assert.expect(1);

      assert.deepEqual(fp.zipObject(['a', 'b'])([1, 2]), { 'a': 1, 'b': 2 });
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.zipWith');

  (function() {
    QUnit.test('should zip arrays combining grouped elements with `iteratee`', function(assert) {
      assert.expect(1);

      var array1 = [1, 2, 3],
          array2 = [4, 5, 6],
          actual = fp.zipWith(add)(array1)(array2);

      assert.deepEqual(actual, [5, 7, 9]);
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.config.asyncRetries = 10;
  QUnit.config.hidepassed = true;

  if (!document) {
    QUnit.config.noglobals = true;
    QUnit.load();
    QUnit.start();
  }
}.call(this));

# Advanced Patterns

```{currentmodule} click
```

In addition to common functionality, Click offers some advanced features.

```{contents}
:depth: 1
:local: true
```

## Callbacks and Eager Options

Sometimes, you want a parameter to completely change the execution flow.
For instance, this is the case when you want to have a `--version`
parameter that prints out the version and then exits the application.

Note: an actual implementation of a `--version` parameter that is
reusable is available in Click as {func}`click.version_option`. The code
here is merely an example of how to implement such a flag.

In such cases, you need two concepts: eager parameters and a callback. An
eager parameter is a parameter handled before others, and a
callback is what executes after the parameter is handled. The eagerness
is necessary so that an earlier required parameter does not produce an
error message. For instance, if `--version` was not eager and a
parameter `--foo` was required and defined before, you would need to
specify it for `--version` to work. For more information, see
{ref}`callback-evaluation-order`.

A callback is a function invoked with three parameters: the
current {class}`Context`, the current {class}`Parameter`, and the value.
The context provides some useful features such as quitting the
application and gives access to other already processed parameters.

Here's an example for a `--version` flag:

```{eval-rst}
.. click:example::

    def print_version(ctx, param, value):
        if not value or ctx.resilient_parsing:
            return
        click.echo('Version 1.0')
        ctx.exit()

    @click.command()
    @click.option('--version', is_flag=True, callback=print_version,
                  expose_value=False, is_eager=True)
    def hello():
        click.echo('Hello World!')


What it looks like:


.. click:run::

    invoke(hello)
    invoke(hello, args=['--version'])
```
The `expose_value` parameter prevents the pretty pointless `version`
parameter from being passed to the callback. If that was not specified, a
boolean would be passed to the `hello` script. The `resilient_parsing`
flag is applied to the context if Click wants to parse the command line
without any destructive behavior that would change the execution flow. In
this case, because we would exit the program, we instead do nothing.

## Callbacks for Validation

```{versionchanged} 2.0
```

If you want to apply custom validation logic, you can do this in the
parameter callbacks. These callbacks can both modify values and
raise errors if the validation does not work. The callback runs after
type conversion. It is called for all sources, including prompts.

In Click 1.0, you can only raise the {exc}`UsageError` but starting with
Click 2.0, you can also raise the {exc}`BadParameter` error, which has the
added advantage that it will automatically format the error message to
also contain the parameter name.

```{eval-rst}
.. click:example::

    def validate_rolls(ctx, param, value):
        if isinstance(value, tuple):
            return value

        try:
            rolls, _, dice = value.partition("d")
            return int(dice), int(rolls)
        except ValueError:
            raise click.BadParameter("format must be 'NdM'")

    @click.command()
    @click.option(
        "--rolls", type=click.UNPROCESSED, callback=validate_rolls,
        default="1d6", prompt=True,
    )
    def roll(rolls):
        sides, times = rolls
        click.echo(f"Rolling a {sides}-sided dice {times} time(s)")

.. click:run::

    invoke(roll, args=["--rolls=42"])
    println()
    invoke(roll, args=["--rolls=2d12"])
    println()
    invoke(roll, input=["42", "2d12"])
```

## Parameter Modifications

Parameters (options and arguments) are forwarded to the command callbacks,
as you have seen. One common way to prevent a parameter from being passed
to the callback is the `expose_value` argument to a parameter which hides
the parameter entirely. The way this works is that the {class}`Context`
object has a {attr}`~Context.params` attribute which is a dictionary of
all parameters. Whatever is in that dictionary is being passed to the
callbacks.

This can be used to make up additional parameters. Generally, this pattern
is not recommended, but in some cases it can be useful. At the very least,
it's good to know that the system works this way.

```{eval-rst}
.. click:example::

    import urllib.request

    def open_url(ctx, param, value):
        if value is not None:
            ctx.params['fp'] = urllib.request.urlopen(value)
            return value

    @click.command()
    @click.option('--url', callback=open_url)
    def cli(url, fp=None):
        if fp is not None:
            click.echo(f"{url}: {fp.code}")

In this case the callback returns the URL unchanged but also passes a
second `fp` value to the callback.

.. caution::

   Writing to :attr:`~click.Context.params` directly bypasses Click's
   per-parameter pipeline: :meth:`~click.Context.get_parameter_source` returns
   ``None`` for it, the value is never run through any :class:`~click.ParamType`
   conversion. And if the key collides with a declared parameter, then the
   shared-name arbitration loses information about where the value came from.
   Prefer the wrapper pattern below when any of those semantics matter.

What's more recommended is to pass the information in a wrapper, however:

.. click:example::

    import urllib.request

    class URL:
        def __init__(self, url, fp):
            self.url = url
            self.fp = fp

    def open_url(ctx, param, value):
        if value is not None:
            return URL(value, urllib.request.urlopen(value))

    @click.command()
    @click.option('--url', callback=open_url)
    def cli(url):
        if url is not None:
            click.echo(f"{url.url}: {url.fp.code}")

```

## Token Normalization

```{versionadded} 2.0
```

Starting with Click 2.0, it's possible to provide a function used
for normalizing tokens. Tokens are option names, choice values, or command
values. This can be used to implement case-insensitive options, for
instance.

To use this feature, the context needs to be passed a function that
performs the normalization of the token. Such as a function that converts the
token to lowercase:

```{eval-rst}
.. click:example::

    CONTEXT_SETTINGS = {'token_normalize_func': lambda x: x.lower()}

    @click.command(context_settings=CONTEXT_SETTINGS)
    @click.option('--name', default='Pete')
    def cli(name):
        click.echo(f"Name: {name}")

# And how it works on the command line:

.. click:run::

    invoke(cli, prog_name='cli', args=['--NAME=Pete'])
```

## Invoking Other Commands

Sometimes, it might be interesting to invoke one command from another
command. This is a pattern generally discouraged with Click, but
possible nonetheless. For this, you can use the {func}`Context.invoke`
or {func}`Context.forward` methods.

They work similarly, but the difference is that {func}`Context.invoke` merely
invokes another command with the arguments you provide as a caller,
whereas {func}`Context.forward` fills in the arguments from the current
command. Both accept the command as the first argument, and everything else
is passed onwards as you would expect.

Example:

```{eval-rst}
.. click:example::

    cli = click.Group()

    @cli.command()
    @click.option('--count', default=1)
    def test(count):
        click.echo(f'Count: {count}')

    @cli.command()
    @click.option('--count', default=1)
    @click.pass_context
    def dist(ctx, count):
        ctx.forward(test)
        ctx.invoke(test, count=42)

And what it looks like:

.. click:run::

    invoke(cli, prog_name='cli', args=['dist'])
```

(forwarding-unknown-options)=

## Forwarding Unknown Options

In some situations, it is interesting to be able to accept all unknown
options for further manual processing. Click can generally do that as of
Click 4.0, but it has some limitations that lie in the nature of the
problem. The support for this is provided through a parser flag called
`ignore_unknown_options` which will instruct the parser to collect all
unknown options and to put them to the leftover argument instead of
triggering a parsing error.

This can generally be activated in two different ways:

1. It can be enabled on custom {class}`Command` subclasses by changing
   the {attr}`~Command.ignore_unknown_options` attribute.
2. It can be enabled by changing the attribute of the same name on the
   context class ({attr}`Context.ignore_unknown_options`). This is best
   changed through the `context_settings` dictionary on the command.

For most situations, the easiest solution is the second. Once the behavior
is changed, something needs to pick up those leftover options (which at
this point are considered arguments). For this again, you have two
options:

1. You can use {func}`pass_context` to get the context passed. This will
   only work if in addition to {attr}`~Context.ignore_unknown_options`
   you also set {attr}`~Context.allow_extra_args` as otherwise the
   command will abort with an error that there are leftover arguments.
   If you go with this solution, the extra arguments will be collected in
   {attr}`Context.args`.
2. You can attach an {func}`argument` with `nargs` set to `-1` which
   will eat up all leftover arguments. In this case it's recommended to
   set the `type` to {data}`UNPROCESSED` to avoid any string processing
   on those arguments as otherwise they are forced into Unicode strings
   automatically which is often not what you want.

In the end, the result looks something like this:

```{eval-rst}
.. click:example::

    from subprocess import call

    @click.command(context_settings={'ignore_unknown_options': True})
    @click.option('-v', '--verbose', is_flag=True, help='Enables verbose mode')
    @click.argument('timeit_args', nargs=-1, type=click.UNPROCESSED)
    def cli(verbose, timeit_args):
        """A fake wrapper around Python's timeit."""
        cmdline = ['echo', 'python', '-mtimeit', *timeit_args]
        if verbose:
            click.echo(f"Invoking: {' '.join(cmdline)}")
        call(cmdline)


And the final output resembles the following:

.. click:run::

    invoke(cli, prog_name='cli', args=['--help'])
    println()
    invoke(cli, prog_name='cli', args=['-n', '100', 'a = 1; b = 2; a * b'])
    println()
    invoke(cli, prog_name='cli', args=['-v', 'a = 1; b = 2; a * b'])
```

As you can see, Click handles the verbosity flag and everything else
ends up in the `timeit_args` variable for further processing, which then
for instance, allows invoking a subprocess. There are a few things that
are important to know about how this ignoring of unhandled flag happens:

- Unknown long options are generally ignored and not processed at all.
  So for instance if `--foo=bar` or `--foo bar` are passed they
  generally end up like that. Note that because the parser cannot know
  if an option will accept an argument or not, the `bar` part might be
  handled as an argument.
- Unknown short options might be partially handled and reassembled if
  necessary. For instance in the above example there is an option
  called `-v` which enables verbose mode. If the command would be
  invoked with `-va` then the `-v` part would be handled by Click
  (as it is known) and `-a` would end up in the leftover parameters
  for further processing.
- Depending on what you plan on doing you might have some success by
  disabling interspersed arguments
  ({attr}`~Context.allow_interspersed_args`) which instructs the parser
  to not allow arguments and options to be mixed. Depending on your
   situation, this might improve your results.

Generally, combining the handling of options and arguments from your own
commands with those from another application is discouraged, and you
should avoid it if possible. It's a much better idea to have
everything below a subcommand be forwarded to another application than to
handle some arguments yourself.

## Managing Resources

It can be useful to open a resource in a group, to be made available to
subcommands. Many types of resources need to be closed or otherwise
cleaned up after use. The standard way to do this in Python is by using
a context manager with the `with` statement.

For example, the `Repo` class from {doc}`complex` might actually be
defined as a context manager:

```python
class Repo:
    def __init__(self, home=None):
        self.home = os.path.abspath(home or ".")
        self.db = None

    def __enter__(self):
        path = os.path.join(self.home, "repo.db")
        self.db = open_database(path)
        return self

    def __exit__(self, exc_type, exc_value, tb):
        self.db.close()
```

Ordinarily, it would be used with the `with` statement:

```python
with Repo() as repo:
    repo.db.query(...)
```

However, a `with` block in a group would exit and close the database
before it could be used by a subcommand.

Instead, use the context's {meth}`~click.Context.with_resource` method
to enter the context manager and return the resource. When the group and
any subcommands finish, the context's resources are cleaned up.

```python
@click.group()
@click.option("--repo-home", default=".repo")
@click.pass_context
def cli(ctx, repo_home):
    ctx.obj = ctx.with_resource(Repo(repo_home))

@cli.command()
@click.pass_obj
def log(obj):
    # obj is the repo opened in the cli group
    for entry in obj.db.query(...):
        click.echo(entry)
```

If the resource isn't a context manager, usually it can be wrapped in
one using something from {mod}`contextlib`. If that's not possible, use
the context's {meth}`~click.Context.call_on_close` method to register a
cleanup function.

```python
@click.group()
@click.option("--name", default="repo.db")
@click.pass_context
def cli(ctx, name):
    ctx.obj = db = open_db(name)

    @ctx.call_on_close
    def close_db():
        db.record_use()
        db.save()
        db.close()
```

```{versionchanged} 8.2
`Context.call_on_close` and context managers registered via `Context.with_resource`
will be closed when the CLI exits. These were previously not called on exit.
```

Aksjomat indukcji – aksjomat, a właściwie nieskończony przeliczalny zbiór aksjomatów pierwszego rzędu, pozalogicznych rozważany zwłaszcza w teorii arytmetyki liczb naturalnych. Jest on formalizacją zasady indukcji matematycznej.

Jego treść przedstawia się następująco:
 

gdzie  oznacza: „dla każdego n” ⇒, to wynikanie (implikacja)  oznacza „i”. Tak wyrażony aksjomat indukcji nie spełnia jednak założeń rozlicznych podejść, a w tym np. analizy Gödla niesprzeczności teorii matematycznych w szczególności arytmetyki. Problemem jest zupełna nieobliczalność relacji użytych do konstrukcji powyższego zdania: kwantyfikator ogólny „dla każdego n” nie da się bowiem zapisać jako funkcja obliczalna. Ponadto zdanie powyższe jest zdaniem drugiego rzędu z uwagi na użycie kwantyfikatora, co sprawia, że operuje ono obiektami niezdefiniowanymi w teorii (zbiorem liczb naturalnych n, z którego mamy wybierać wartości: nie można go skonstruować, zanim nie ustalimy listy aksjomatów i nie udowodnimy ich niesprzeczności).

Równoważnie aksjomat indukcji można zapisać jako koniunkcję zbioru aksjomatów w następującej postaci:
 

w której to notacji nie został użyty nieograniczony, a więc nieobliczalny (nierekurencyjny) kwantyfikator ogólny, wszystkie zdania są zaś pierwszego rzędu (wyrażają prawdy o zdefiniowanych wcześniej pojęciach pierwotnych arytmetyki, nie używając kwantyfikatora ogólnego). Uzyskujemy w ten sposób formalną poprawność sformułowania aksjomatu.

Aksjomaty indukcji są ważnym elementem teorii arytmetyki.

Znane są przykłady twierdzeń, w których chociaż znamy dowody twierdzenia  dla każdego  to twierdzenie  nie może być dowiedzione w ramach arytmetyki liczb naturalnych (jest niedowiedlne), gdyż każdy z tych dowodów jest prowadzony za pomocą innych narzędzi i nie da się ich sprowadzić do kroku indukcyjnego (a więc rozumowania wykazującego ), zapisanego za pomocą języka arytmetyki i obejmującego wszystkie możliwe wartości  (dla każdego n pojawia się pewien nowy element niewystępujący dla innych ).

Zobacz też 
 aksjomat nieskończoności
 indukcja matematyczna

Bibliografia 
 Roman Murawski, Funkcje rekurencyjne i elementy metamatematyki. Problemy zupełności, rozstrzygalności, twierdzenia Gödla, Wydawnictwo Naukowe UAM, Poznań 1990.

Logika matematyczna

Annamocarya es un género monotípico de árboles de la familia Juglandaceae. Su única especie, Annamocarya sinensis es nativa del sudoeste de China (Guangxi, Guizhou, Yunnan) y norte de Vietnam. Se relaciona con Carya, y estaba incluida en el mismo género homónimo, como Carya sinensis, pero compartía ciertos  caracteres con Juglans.

Descripción 
Es un árbol de medio a grande, siempreverde de hasta 30 m de altura. Las hojas son de 3 a 5 dm de longitud, pinnadas con 7 a 11 folíolos que tienen márgenes enteros, distinguiéndose de Carya por tener bordes aserrados. Las flores tienen amentos producidos en primavera, con los amentos masculino en manojos de 5 a 8 juntos (simples en Carya). El fruto es una nuez de 6 a 8 cm de long. y 4 a 6 cm de ancho, con un prominente pico agudo en un extremo.

Taxonomía 
El género fue descrito por Auguste Jean Baptiste Chevalier y publicado en Revue de Botanique Appliquée et d'Agriculture Tropicale, 21, p. 504 en el año 1941.

Sinonimia 
 Annamocarya indochinensis (A.Chev.) A. Chev.
 Carya integrifoliolata (Kuang) Hjelmq.
 Carya sinensis Dode
 Carya tsiangiana Chun ex Lee
 Carya tsiangii Chun ex Kuang & A.M.Lu
 Juglandicarya integrifoliolata (Kuang) Hu
 Juglans indochinensis A. Chev.
 Rhamphocarya integrifoliolata Kuang

Referencias

Bibliografía 
 Flora of China Editorial Committee, 1999. Fl. China Vol. 4.

Enlaces externos 
 Annamocarya en eFlora''

Juglandaceae
Flora de China
Flora de Indochina
Flora de Asia continental

Aikido ( ,  , , ) is a modern Japanese martial art that is split into many different styles, including Iwama Ryu, Iwama Shin Shin Aiki Shuren Kai, Shodokan Aikido, Yoshinkan, Renshinkai, Aikikai and Ki Aikido. Aikido is now practiced in around 140 countries. It was originally developed by Morihei Ueshiba, as a synthesis of his martial studies, philosophy and religious beliefs. Ueshiba's goal was to create an art that practitioners could use to defend themselves while also protecting their attackers from injury. Aikido is often translated as "the way of unifying (with) life energy" or as "the way of harmonious spirit". According to the founder's philosophy, the primary goal in the practice of aikido is to overcome oneself instead of cultivating violence or aggressiveness. Morihei Ueshiba used the phrase  to refer to this principle.

Aikido's fundamental principles include:  (entering), ,  (breathing control),  (triangular principle) and  (turning) movements that redirect the opponent's attack momentum. Its curriculum comprises various techniques, primarily throws and joint locks. It also includes a weapons system encompassing the ,  and .

Aikido derives mainly from the martial art of Daitō-ryū Aiki-jūjutsu, but began to diverge from it in the late 1920s, partly due to Ueshiba's involvement with the Ōmoto-kyō religion. Ueshiba's early students' documents bear the term .

Ueshiba's senior students have different approaches to aikido, depending partly on when they studied with him. Today, aikido is found all over the world in a number of styles, with broad ranges of interpretation and emphasis. However, they all share techniques formulated by Ueshiba and most have concern for the well-being of the attacker.

Etymology and basic philosophy

The word "aikido" is formed of three kanji:
  –  – harmony, unifying
  –  – energy, spirit
  –  – way, path

The term  does not readily appear in the Japanese language outside the scope of budō. This has led to many possible interpretations of the word.

 () is mainly used in compounds to mean 'combine, unite, join together, meet', examples being  (combined/united),  (composition),  (unite/combine/join together),  (union/alliance/association),  (combine/unify), and  (mutual agreement). There is an idea of reciprocity,  (to get to know one another),  (talk/discussion/negotiation), and  (meet by appointment).

 () is often used to describe a feeling or emotive action, as in  ('I feel X', as in terms of thinking but with less cognitive reasoning), and  (feeling/sensation); it is used to mean energy or force, as in  (electricity) and  (magnetism); it can also refer to qualities or aspects of people or things, as in  (spirit/trait/temperament). The characters aeteological history can be traced back to the much older Chinese character of  () that is used extensively in Traditional Chinese medicine and acupunture.

The term  in Aikido is found in many other Japanese martial arts such as, judo and kendo, and in various non-martial arts, such as Japanese calligraphy (), flower arranging () and tea ceremony ( or ).

Therefore, from a purely literal interpretation, aikido is the "Way of combining forces" or "Way of unifying energy", in which the term  refers to the martial arts principle or tactic of blending with an attacker's movements for the purpose of controlling their actions with minimal effort. One applies  by understanding the rhythm and intent of the attacker to find the optimal position and timing to apply a counter-technique.

History

Aikido was created by  (1883–1969), referred to by some aikido practitioners as  (Great Teacher). The term aikido was coined in the 20th century. Ueshiba envisioned aikido not only as the synthesis of his martial training, but as an expression of his personal philosophy of universal peace and reconciliation. During Ueshiba's lifetime and continuing today, aikido has evolved from the  that Ueshiba studied into a variety of expressions by martial artists throughout the world.

Initial development

Ueshiba developed aikido primarily during the late 1920s through the 1930s through the synthesis of the older martial arts that he had studied. The core martial art from which aikido derives is Daitō-ryū Aiki-jūjutsu, which Ueshiba studied directly with Takeda Sōkaku, the reviver of that art. Additionally, Ueshiba is known to have studied Tenjin Shin'yō-ryū with Tozawa Tokusaburō in Tokyo in 1901, Gotōha Yagyū Shingan-ryū under Nakai Masakatsu in Sakai from 1903 to 1908, and judo with  (1894–1972) in Tanabe in 1911.

The art of  is the primary technical influence on aikido. Along with empty-handed throwing and joint-locking techniques, Ueshiba incorporated training movements with weapons, such as those for the spear (), short staff (), and possibly the . Aikido also derives much of its technical structure from the art of swordsmanship ().

Ueshiba moved to Hokkaidō in 1912, and began studying under Takeda Sokaku in 1915; His official association with Daitō-ryū continued until 1937. However, during the latter part of that period, Ueshiba had already begun to distance himself from Takeda and the . At that time Ueshiba referred to his martial art as "Aiki Budō". It is unclear exactly when Ueshiba began using the name "aikido", but it became the official name of the art in 1942 when the Greater Japan Martial Virtue Society () was engaged in a government sponsored reorganization and centralization of Japanese martial arts.

Religious influences

After Ueshiba left Hokkaidō in 1919, he met and was profoundly influenced by Onisaburo Deguchi, the spiritual leader of the Ōmoto-kyō religion (a neo-Shinto movement) in Ayabe. One of the primary features of Ōmoto-kyō is its emphasis on the attainment of utopia during one's life. This idea was a great influence on Ueshiba's martial arts philosophy of extending love and compassion especially to those who seek to harm others. Aikido demonstrates this philosophy in its emphasis on mastering martial arts so that one may receive an attack and harmlessly redirect it. In an ideal resolution, not only is the receiver unharmed, but so is the attacker.

In addition to the effect on his spiritual growth, the connection with Deguchi gave Ueshiba entry to elite political and military circles as a martial artist. As a result of this exposure, he was able to attract not only financial backing but also gifted students. Several of these students would found their own styles of aikido.

International dissemination
Aikido was first introduced to the rest of the world in 1951 by Minoru Mochizuki with a visit to France, where he demonstrated aikido techniques to judo students. He was followed by Tadashi Abe in 1952, who came as the official Aikikai Hombu representative, remaining in France for seven years. Kenji Tomiki toured with a delegation of various martial arts through 15 continental states of the United States in 1953. Later that year, Koichi Tohei was sent by Aikikai Hombu to Hawaii for a full year, where he set up several dōjō. This trip was followed by several subsequent visits and is considered the formal introduction of aikido to the United States. The United Kingdom followed in 1955; Italy in 1964 by Hiroshi Tada; and Germany in 1965 by Katsuaki Asai. Designated the "Official Delegate for Europe and Africa" by Morihei Ueshiba, Masamichi Noro arrived in France in September 1961. Seiichi Sugano was appointed to introduce aikido to Australia in 1965. Today there are aikido dōjō throughout the world.

Proliferation of independent organizations

The largest aikido organization is the Aikikai Foundation, which remains under the control of the Ueshiba family. However, aikido has developed into many styles, most of which were formed by Morihei Ueshiba's major students.

The earliest independent styles to emerge were Yoseikan Aikido, begun by Minoru Mochizuki in 1931, Yoshinkan Aikido, founded by Gozo Shioda in 1955, and Shodokan Aikido, founded by Kenji Tomiki in 1967. The emergence of these styles pre-dated Ueshiba's death and did not cause any major upheavals when they were formalized. Shodokan Aikido, however, was controversial, since it introduced a unique rule-based competition that some felt was contrary to the spirit of aikido.

After Ueshiba's death in 1969, two more major styles emerged. Significant controversy arose with the departure of the Aikikai Hombu Dojo's chief instructor Koichi Tohei, in 1974. Tohei left as a result of a disagreement with the son of the founder, Kisshomaru Ueshiba, who at that time headed the Aikikai Foundation. The disagreement was over the proper role of  development in regular aikido training. After Tohei left, he formed his own style, called Shin Shin Toitsu Aikido, and the organization that governs it, the Ki Society ().

A final major style evolved from Ueshiba's retirement in Iwama, Ibaraki and the teaching methodology of long term student Morihiro Saito. It is unofficially referred to as the "Iwama style", and at one point a number of its followers formed a loose network of schools they called Iwama Ryu. Although Iwama style practitioners remained part of the Aikikai until Saito's death in 2002, followers of Saito subsequently split into two groups. One remained with the Aikikai and the other formed the independent Shinshin Aikishuren Kai in 2004 around Saito's son Hitohiro Saito.

Today, the major styles of aikido are each run by a separate governing organization, have their own  in Japan, and are taught throughout the world.

The study of  is an important component of aikido. The term does not specifically refer to either physical or mental training, as it encompasses both. The kanji for  was written in its older form as  up until the Japanese governmental writing reforms after World War II, and now is more prevalently seen in its modern form of . This form has the removal of the eight directions denoting the pre and post natal energies of  (Chinese – ) also known in the Art of Aikido as "Source energy".

The character for  is used in everyday Japanese terms, such as , or .  has many meanings, including "ambience", "mind", "mood", or "intention and action", however, in traditional martial arts and medicine it is often referred to in its more general terminology as "life energy". Gozo Shioda's Yoshinkan Aikido, considered one of the "hard styles", largely follows Ueshiba's teachings from before World War II, and surmises that the secret to  lies in timing and the application of the whole body's strength to a single point. In later years, Ueshiba's application of  in aikido took on a softer, more gentle feel. This concept was known as Takemusu Aiki, and many of his later students teach about  from this perspective. Koichi Tohei's Ki Society centers almost exclusively around the study of the empirical (albeit subjective) experience of , with students' proficiency in aikido techniques and  development ranked separately.

Training

In aikido, as in virtually all Japanese martial arts, there are both physical and mental aspects of training. The physical training in aikido is diverse, covering both general physical fitness and conditioning, as well as specific techniques. Because a substantial portion of any aikido curriculum consists of throws, beginners learn how to safely fall or roll. The specific techniques for attack include both strikes and grabs; the techniques for defense consist of throws and pins. After basic techniques are learned, students study freestyle defense against multiple opponents, and techniques with weapons.

Fitness
Physical training goals pursued in conjunction with aikido include controlled relaxation, correct movement of joints such as hips and shoulders, flexibility, and endurance, with less emphasis on strength training. In aikido, pushing or extending movements are much more common than pulling or contracting movements. This distinction can be applied to general fitness goals for the aikido practitioner.

In aikido, specific muscles or muscle groups are not isolated and worked to improve tone, mass, or power. Aikido-related training emphasizes the use of coordinated whole-body movement and balance similar to yoga or pilates. For example, many dōjōs begin each class with , which may include stretching and  (break falls).

Roles of  and 
 
Aikido training is based primarily on two partners practicing pre-arranged forms () rather than freestyle practice. The basic pattern is for the receiver of the technique () to initiate an attack against the person who applies the technique—the , or  (depending on aikido style), also referred to as  (when applying a throwing technique), who neutralises this attack with an aikido technique.

Both halves of the technique, that of  and that of , are considered essential to aikido training. Both are studying aikido principles of blending and adaptation.  learns to blend with and control attacking energy, while  learns to become calm and flexible in the disadvantageous, off-balance positions in which  places them. This "receiving" of the technique is called .  continuously seeks to regain balance and cover vulnerabilities (e.g., an exposed side), while  uses position and timing to keep  off-balance and vulnerable. In more advanced training,  will sometimes apply  to regain balance and pin or throw .

 refers to the act of receiving a technique. Good  involves attention to the technique, the partner, and the immediate environment—it is considered an active part of the process of learning aikido. The method of falling itself is also important, and is a way for the practitioner to receive an aikido technique safely and minimize risk of injury.

Initial attacks
Aikido techniques are usually a defense against an attack, so students must learn to deliver various types of attacks to be able to practice aikido with a partner. Although attacks are not studied as thoroughly as in striking-based arts, attacks with intent (such as a strong strike or an immobilizing grab) are needed to study correct and effective application of technique.

Many of the  of aikido resemble cuts from a sword or other grasped object, which indicate its origins in techniques intended for armed combat. Other techniques, which explicitly appear to be punches (), are practiced as thrusts with a knife or sword. Kicks are generally reserved for upper-level variations; reasons cited include that falls from kicks are especially dangerous, and that kicks (high kicks in particular) were uncommon during the types of combat prevalent in feudal Japan.

Some basic strikes include:
  is a vertical knifehand strike to the head. In training, this is usually directed at the forehead or the crown for safety, but more dangerous versions of this attack target the bridge of the nose and the maxillary sinus.
  is a diagonal knifehand strike to the side of the head or neck.
  is a punch to the torso. Specific targets include the chest, abdomen, and solar plexus, sometimes referred to as , or .
  is a punch to the face, sometimes referred to as .

Beginners in particular often practice techniques from grabs, both because they are safer and because it is easier to feel the energy and the direction of the movement of force of a hold than it is for a strike. Some grabs are historically derived from being held while trying to draw a weapon, whereupon a technique could then be used to free oneself and immobilize or strike the attacker while they are grabbing the defender. The following are examples of some basic grabs:
 , when one hand grabs one wrist.
 , when both hands grab one wrist; sometimes referred to as 
 , when both hands grab both wrists; sometimes referred to as .
  when one shoulder is grabbed.
 , when both shoulders are grabbed. It is sometimes combined with an overhead strike as .
 , when the lapel is grabbed; sometimes referred to as .

Basic techniques

The following are a sample of the basic or widely practiced throws and pins. Many of these techniques derive from Daitō-ryū Aiki-jūjutsu, but some others were invented by Morihei Ueshiba. The precise terminology for some may vary between organisations and styles; the following are the terms used by the Aikikai Foundation. Note that despite the names of the first five techniques listed, they are not universally taught in numeric order.
 , a control technique using one hand on the elbow and one hand near the wrist which leverages  to the ground. This grip applies pressure into the ulnar nerve at the wrist.
  is a pronating wristlock that torques the arm and applies painful nerve pressure. (There is an adductive wristlock or Z-lock in the  version.)
  is a rotational wristlock that directs upward-spiraling tension throughout the arm, elbow and shoulder.
  is a shoulder control technique similar to , but with both hands gripping the forearm. The knuckles (from the palm side) are applied to the recipient's radial nerve against the periosteum of the forearm bone.
 is a technique that is visually similar to , but with an inverted grip of the wrist, medial rotation of the arm and shoulder, and downward pressure on the elbow. Common in knife and other weapon take-aways.
  is a throw during which 's hand is folded back past the shoulder, locking the shoulder joint.
  is a supinating wristlock-throw that stretches the extensor digitorum.
  is a loosely used umbrella term for various types of mechanically unrelated techniques;  generally do not use joint locks like other techniques.
 , throws in which  moves through the space occupied by . The classic form superficially resembles a "clothesline" technique.
 , a throw in which, beginning with , moving forward,  sweeps one hand low ("earth") and the other high ("heaven"), which unbalances  so that he or she easily topples over.
 , aikido's version of the hip throw;  drops their hips lower than those of , then flips  over the resultant fulcrum.
  or , a throw that locks the arms against each other (the kanji for "10" is a cross-shape: ).
  is a throw in which  sweeps 's arm back until it locks the shoulder joint, then uses forward pressure to throw them.

Implementations

Aikido makes use of body movement () to blend the movement of  with the movement of . For example, an "entering" () technique consists of movements inward towards , while a  technique uses a pivoting motion.
Additionally, an  technique takes place in front of , whereas an  technique takes place to their side; a  technique is applied with motion to the front of , and a  version is applied with motion towards the rear of , usually by incorporating a turning or pivoting motion. Finally, most techniques can be performed while in a seated posture (). Techniques where both  and  are standing are called , techniques where both start off in  are called , and techniques performed with  standing and  sitting are called  ().

From these few basic techniques, there are numerous of possible implementations. For example,  can be applied to an opponent moving forward with a strike (perhaps with an  type of movement to redirect the incoming force), or to an opponent who has already struck and is now moving back to reestablish distance (perhaps an  version). Specific aikido  are typically referred to with the formula "attack-technique(-modifier)"; , for example, refers to any  technique executed when  is holding one wrist. This could be further specified as  (referring to any forward-moving  technique from that grab).

 are strikes (or feints) employed during an aikido technique. Some view  as attacks against "vital points" meant to cause damage in and of themselves. For instance, Gozo Shioda described using  in a brawl to quickly down a gang's leader. Others consider , especially to the face, to be methods of distraction meant to enable other techniques; a strike, even if it is blocked, can startle the target and break their concentration. Additionally, the target may also become unbalanced while attempting to avoid a strike (by jerking the head back, for example) which may allow for an easier throw. Many sayings about  are attributed to Morihei Ueshiba, who considered them an essential element of technique.

Weapons

Weapons training in aikido traditionally includes the short staff () (these techniques closely resemble the use of the bayonet, or Jūkendō), the wooden sword (), and the knife (). Some schools incorporate firearm-disarming techniques, where either weapon-taking and/or weapon-retention may be taught. Some schools, such as the Iwama style of Morihiro Saito, usually spend substantial time practicing with both  and , under the names of , and , respectively.

The founder developed many of the empty-handed techniques from traditional sword, spear and bayonet movements. Consequently, the practice of the weapons arts gives insight into the origin of techniques and movements, and reinforces the concepts of distance, timing, foot movement, presence and connectedness with one's training partner(s).

Multiple attackers and 
One feature of aikido is training to defend against multiple attackers, often called , or . Freestyle practice with multiple attackers called  is a key part of most curricula and is required for the higher-level ranks.  exercises a person's ability to intuitively perform techniques in an unstructured environment. Strategic choice of techniques, based on how they reposition the student relative to other attackers, is important in  training. For instance, an  technique might be used to neutralise the current attacker while turning to face attackers approaching from behind.

In Shodokan Aikido,  differs in that it is not performed with multiple persons with defined roles of defender and attacker, but between two people, where both participants attack, defend, and counter at will. In this respect it resembles judo .

Injuries
In applying a technique during training, it is the responsibility of  to prevent injury to  by employing a speed and force of application that is appropriate with their partner's proficiency in . When injuries (especially to the joints) occur, they are often the result of a  misjudging the ability of  to receive the throw or pin.

A study of injuries in the martial arts showed that the type of injuries varied considerably from one art to the other. Soft tissue injuries are one of the most common types of injuries found within aikido, as well as joint strain and stubbed fingers and toes. Several deaths from head-and-neck injuries, caused by aggressive  in a  hazing context, have been reported.

Mental training
Aikido training is mental as well as physical, emphasizing the ability to relax the mind and body even under the stress of dangerous situations. This is necessary to enable the practitioner to perform the 'enter-and-blend' movements that underlie aikido techniques, wherein an attack is met with confidence and directness. Morihei Ueshiba once remarked that one "must be willing to receive 99% of an opponent's attack and stare death in the face" in order to execute techniques without hesitation. As a martial art concerned not only with fighting proficiency but with the betterment of daily life, this mental aspect is of key importance to aikido practitioners.

Uniforms and ranking

Aikido practitioners (commonly called  outside Japan) generally progress by promotion through a series of "grades" (), followed by a series of "degrees" (), pursuant to formal testing procedures. Some aikido organizations use belts to distinguish practitioners' grades, often simply white and black belts to distinguish  and  grades, although some use various belt colors. Testing requirements vary, so a particular rank in one organization is not comparable or interchangeable with the rank of another. Some dōjōs have an age requirement before students can take the  rank exam.

The uniform worn for practicing aikido () is similar to the training uniform () used in most other modern martial arts; simple trousers and a wraparound jacket, usually white. Both thi

use log::{debug, error, info, trace, warn, Level, LevelFilter, Log, Metadata, Record};
use std::sync::{Arc, Mutex};

#[cfg(feature = "std")]
use log::set_boxed_logger;
#[cfg(not(feature = "std"))]
fn set_boxed_logger(logger: Box<dyn Log>) -> Result<(), log::SetLoggerError> {
    log::set_logger(Box::leak(logger))
}

struct State {
    last_log: Mutex<Option<Level>>,
}

struct Logger(Arc<State>);

impl Log for Logger {
    fn enabled(&self, _: &Metadata) -> bool {
        true
    }

    fn log(&self, record: &Record) {
        *self.0.last_log.lock().unwrap() = Some(record.level());
    }

    fn flush(&self) {}
}

fn main() {
    let me = Arc::new(State {
        last_log: Mutex::new(None),
    });
    let a = me.clone();
    set_boxed_logger(Box::new(Logger(me))).unwrap();

    test(&a, LevelFilter::Off);
    test(&a, LevelFilter::Error);
    test(&a, LevelFilter::Warn);
    test(&a, LevelFilter::Info);
    test(&a, LevelFilter::Debug);
    test(&a, LevelFilter::Trace);
}

fn test(a: &State, filter: LevelFilter) {
    log::set_max_level(filter);
    error!("");
    last(&a, t(Level::Error, filter));
    warn!("");
    last(&a, t(Level::Warn, filter));
    info!("");
    last(&a, t(Level::Info, filter));

    debug!("");
    if cfg!(debug_assertions) {
        last(&a, t(Level::Debug, filter));
    } else {
        last(&a, None);
    }

    trace!("");
    last(&a, None);

    fn t(lvl: Level, filter: LevelFilter) -> Option<Level> {
        if lvl <= filter {
            Some(lvl)
        } else {
            None
        }
    }
}

fn last(state: &State, expected: Option<Level>) {
    let mut lvl = state.last_log.lock().unwrap();
    assert_eq!(*lvl, expected);
    *lvl = None;
}

عصر آزادگان روزنامه‌ای اصلاح‌طلب بود که پس از توقیف روزنامه‌های جامعه، توس و نشاط به مدیرمسئولی غفور گرشاسبی و به سردبیری ماشاالله شمس‌الواعظین منتشر گردید. این روزنامه در ۱۵ مهر ۱۳۷۸ با تیتر یک «بازگشت آزادگان به جامعه» آغز به کار کرد و در جریان توقیف گسترده مطبوعات در اردیبهشت ۱۳۷۹ که به توقیف فله‌ای مشهور شد، پس از چند ماه انتشار توسط قوهٔ قضائیهٔ جمهوری اسلامی ایران توقیف گردید.

دبیران این روزنامه در زمان انتشار:
 اکبر گنجی، که در مورد سرویس مخفی ایران می‌نوشت.
 ابراهیم نبوی، که طنز سیاسی روزانه می‌نوشت.
 حسین درخشان، که یک ستون فناوری به‌طور منظم می‌نوشت.
 مسعود بهنود، که یک ستون نظر به‌طور منظم می‌نوشت.

منابع 

انحلال‌های ۲۰۰۰ (میلادی) در ایران
بنیان‌گذاری‌های ۱۹۹۹ (میلادی) در ایران
رسانه در تهران
روزنامه‌های اصلاح‌طلب ایران
روزنامه‌های بنیان‌گذاری‌شده در ۱۹۹۹ (میلادی)
روزنامه‌های فارسی‌زبان
روزنامه‌های منحل‌شده ایران
نشریه‌های ایران
نشریه‌های بنیان‌گذاری‌شده در ۱۹۹۹ (میلادی)
نشریه‌های توقیف‌شده
نشریه‌های منحل‌شده در ۲۰۰۰ (میلادی)

# Change Log

## [0.4.33] - 2026-06-20

## What's Changed
* Fixed key comparison by @matteo-zeggiotti-ok in https://github.com/rust-lang/log/pull/732

## New Contributors
* @matteo-zeggiotti-ok made their first contribution in https://github.com/rust-lang/log/pull/732

**Full Changelog**: https://github.com/rust-lang/log/compare/0.4.32...0.4.33

## [0.4.32] - 2026-06-04

### What's Changed
* Support `Value` -> string conversions with `kv` + `std` features instead of `kv_std` by @tisonkun in https://github.com/rust-lang/log/pull/729

**Full Changelog**: https://github.com/rust-lang/log/compare/0.4.31...0.4.32

## [0.4.31] - 2026-06-02

### What's Changed
* Leverage static str key when possible by @tisonkun in https://github.com/rust-lang/log/pull/727

### New Contributors
* @Isvane made their first contribution in https://github.com/rust-lang/log/pull/726

**Full Changelog**: https://github.com/rust-lang/log/compare/0.4.30...0.4.31

## [0.4.30] - 2026-05-21

### What's Changed
* Support capturing of `std::net` types by @KodrAus in https://github.com/rust-lang/log/pull/724

### New Contributors
* @V0ldek made their first contribution in https://github.com/rust-lang/log/pull/720
* @woodruffw made their first contribution in https://github.com/rust-lang/log/pull/723

**Full Changelog**: https://github.com/rust-lang/log/compare/0.4.29...0.4.30

### Notable Changes
* MSRV is bumped to 1.71.0 in https://github.com/rust-lang/log/pull/723

## [0.4.29] - 2025-12-02

### What's Changed
* perf: reduce llvm-lines of FromStr for `Level` and `LevelFilter` by @dishmaker in https://github.com/rust-lang/log/pull/709
* Replace serde with serde_core by @Thomasdezeeuw in https://github.com/rust-lang/log/pull/712

### New Contributors
* @AldaronLau made their first contribution in https://github.com/rust-lang/log/pull/703
* @dishmaker made their first contribution in https://github.com/rust-lang/log/pull/709

**Full Changelog**: https://github.com/rust-lang/log/compare/0.4.28...0.4.29

## [0.4.28] - 2025-09-02

### What's Changed
* ci: drop really old trick and ensure MSRV for all feature combo by @tisonkun in https://github.com/rust-lang/log/pull/676
* Chore: delete compare_exchange method for AtomicUsize on platforms without atomics  by @HaoliangXu in https://github.com/rust-lang/log/pull/690
* Add `increment_severity()` and `decrement_severity()` methods for `Level` and `LevelFilter` by @nebkor in https://github.com/rust-lang/log/pull/692

## New Contributors
* @xixishidibei made their first contribution in https://github.com/rust-lang/log/pull/677
* @ZylosLumen made their first contribution in https://github.com/rust-lang/log/pull/688
* @HaoliangXu made their first contribution in https://github.com/rust-lang/log/pull/690
* @nebkor made their first contribution in https://github.com/rust-lang/log/pull/692

**Full Changelog**: https://github.com/rust-lang/log/compare/0.4.27...0.4.28

### Notable Changes
* MSRV is bumped to 1.61.0 in https://github.com/rust-lang/log/pull/676

## [0.4.27] - 2025-03-24

### What's Changed
* A few minor lint fixes by @nyurik in https://github.com/rust-lang/log/pull/671
* Enable clippy support for format-like macros by @nyurik in https://github.com/rust-lang/log/pull/665
* Add an optional logger param by @tisonkun in https://github.com/rust-lang/log/pull/664
* Pass global logger by value, supplied logger by ref by @KodrAus in https://github.com/rust-lang/log/pull/673


**Full Changelog**: https://github.com/rust-lang/log/compare/0.4.26...0.4.27


## [0.4.26] - 2025-02-18

### What's Changed
* Derive `Clone` for `kv::Value` by @SpriteOvO in https://github.com/rust-lang/log/pull/668
* Add `spdlog-rs` link to crate doc by @SpriteOvO in https://github.com/rust-lang/log/pull/669


**Full Changelog**: https://github.com/rust-lang/log/compare/0.4.25...0.4.26

## [0.4.25] - 2025-01-14

### What's Changed
* Revert loosening of kv cargo features by @KodrAus in https://github.com/rust-lang/log/pull/662


**Full Changelog**: https://github.com/rust-lang/log/compare/0.4.24...0.4.25

## [0.4.24] - 2025-01-11

### What's Changed
* Fix up kv feature activation by @KodrAus in https://github.com/rust-lang/log/pull/659


**Full Changelog**: https://github.com/rust-lang/log/compare/0.4.23...0.4.24

## [0.4.23] - 2025-01-10 (yanked)

### What's Changed
* Fix some typos by @Kleinmarb in https://github.com/rust-lang/log/pull/637
* Add logforth to implementation by @tisonkun in https://github.com/rust-lang/log/pull/638
* Add `spdlog-rs` link to README by @SpriteOvO in https://github.com/rust-lang/log/pull/639
* Add correct lifetime to kv::Value::to_borrowed_str by @stevenroose in https://github.com/rust-lang/log/pull/643
* docs: Add logforth as an impl by @tisonkun in https://github.com/rust-lang/log/pull/642
* Add clang_log implementation by @DDAN-17 in https://github.com/rust-lang/log/pull/646
* Bind lifetimes of &str returned from Key by the lifetime of 'k rather than the lifetime of the Key struct by @gbbosak in https://github.com/rust-lang/log/pull/648
* Fix up key lifetimes and add method to try get a borrowed key by @KodrAus in https://github.com/rust-lang/log/pull/653
* Add Ftail implementation by @tjardoo in https://github.com/rust-lang/log/pull/652

### New Contributors
* @Kleinmarb made their first contribution in https://github.com/rust-lang/log/pull/637
* @tisonkun made their first contribution in https://github.com/rust-lang/log/pull/638
* @SpriteOvO made their first contribution in https://github.com/rust-lang/log/pull/639
* @stevenroose made their first contribution in https://github.com/rust-lang/log/pull/643
* @DDAN-17 made their first contribution in https://github.com/rust-lang/log/pull/646
* @gbbosak made their first contribution in https://github.com/rust-lang/log/pull/648
* @tjardoo made their first contribution in https://github.com/rust-lang/log/pull/652

**Full Changelog**: https://github.com/rust-lang/log/compare/0.4.22...0.4.23

## [0.4.22] - 2024-06-27

### What's Changed
* Add some clarifications to the library docs by @KodrAus in https://github.com/rust-lang/log/pull/620
* Add links to `colog` crate by @chrivers in https://github.com/rust-lang/log/pull/621
* adding line_number test + updating some testing infrastructure by @DIvkov575 in https://github.com/rust-lang/log/pull/619
* Clarify the actual set of functions that can race in _racy variants by @KodrAus in https://github.com/rust-lang/log/pull/623
* Replace deprecated std::sync::atomic::spin_loop_hint() by @Catamantaloedis in https://github.com/rust-lang/log/pull/625
* Check usage of max_level features by @Thomasdezeeuw in https://github.com/rust-lang/log/pull/627
* Remove unneeded import by @Thomasdezeeuw in https://github.com/rust-lang/log/pull/628
* Loosen orderings for logger initialization in https://github.com/rust-lang/log/pull/632. Originally by @pwoolcoc in https://github.com/rust-lang/log/pull/599
* Use Location::caller() for file and line info in https://github.com/rust-lang/log/pull/633. Originally by @Cassy343 in https://github.com/rust-lang/log/pull/520

### New Contributors
* @chrivers made their first contribution in https://github.com/rust-lang/log/pull/621
* @DIvkov575 made their first contribution in https://github.com/rust-lang/log/pull/619
* @Catamantaloedis made their first contribution in https://github.com/rust-lang/log/pull/625

**Full Changelog**: https://github.com/rust-lang/log/compare/0.4.21...0.4.22

## [0.4.21] - 2024-02-27

### What's Changed
* Minor clippy nits by @nyurik in https://github.com/rust-lang/log/pull/578
* Simplify Display impl by @nyurik in https://github.com/rust-lang/log/pull/579
* Set all crates to 2021 edition by @nyurik in https://github.com/rust-lang/log/pull/580
* Various changes based on review by @Thomasdezeeuw in https://github.com/rust-lang/log/pull/583
* Fix typo in file_static() method doc by @dimo414 in https://github.com/rust-lang/log/pull/590
* Specialize empty key value pairs by @EFanZh in https://github.com/rust-lang/log/pull/576
* Fix incorrect lifetime in Value::to_str() by @peterjoel in https://github.com/rust-lang/log/pull/587
* Remove some API of the key-value feature by @Thomasdezeeuw in https://github.com/rust-lang/log/pull/585
* Add logcontrol-log and log-reload by @swsnr in https://github.com/rust-lang/log/pull/595
* Add Serialization section to kv::Value docs by @Thomasdezeeuw in https://github.com/rust-lang/log/pull/593
* Rename Value::to_str to to_cow_str by @Thomasdezeeuw in https://github.com/rust-lang/log/pull/592
* Clarify documentation and simplify initialization of `STATIC_MAX_LEVEL` by @ptosi in https://github.com/rust-lang/log/pull/594
* Update docs to 2021 edition, test by @nyurik in https://github.com/rust-lang/log/pull/577
* Add "alterable_logger" link to README.md by @brummer-simon in https://github.com/rust-lang/log/pull/589
* Normalize line ending by @EFanZh in https://github.com/rust-lang/log/pull/602
* Remove `ok_or` in favor of `Option::ok_or` by @AngelicosPhosphoros in https://github.com/rust-lang/log/pull/607
* Use `Acquire` ordering for initialization check by @AngelicosPhosphoros in https://github.com/rust-lang/log/pull/610
* Get structured logging API ready for stabilization by @KodrAus in https://github.com/rust-lang/log/pull/613

### New Contributors
* @nyurik made their first contribution in https://github.com/rust-lang/log/pull/578
* @dimo414 made their first contribution in https://github.com/rust-lang/log/pull/590
* @peterjoel made their first contribution in https://github.com/rust-lang/log/pull/587
* @ptosi made their first contribution in https://github.com/rust-lang/log/pull/594
* @brummer-simon made their first contribution in https://github.com/rust-lang/log/pull/589
* @AngelicosPhosphoros made their first contribution in https://github.com/rust-lang/log/pull/607

## [0.4.20] - 2023-07-11

* Remove rustversion dev-dependency by @Thomasdezeeuw in https://github.com/rust-lang/log/pull/568
* Remove `local_inner_macros` usage by @EFanZh in https://github.com/rust-lang/log/pull/570

## [0.4.19] - 2023-06-10

* Use target_has_atomic instead of the old atomic_cas cfg by @GuillaumeGomez in https://github.com/rust-lang/log/pull/555
* Put MSRV into Cargo.toml by @est31 in https://github.com/rust-lang/log/pull/557

## [0.4.18] - 2023-05-28

* fix Markdown links (again) by @hellow554 in https://github.com/rust-lang/log/pull/513
* add cargo doc to workflow by @hellow554 in https://github.com/rust-lang/log/pull/515
* Apply Clippy lints by @hellow554 in https://github.com/rust-lang/log/pull/516
* Replace ad-hoc eq_ignore_ascii_case with slice::eq_ignore_ascii_case by @glandium in https://github.com/rust-lang/log/pull/519
* fix up windows targets by @KodrAus in https://github.com/rust-lang/log/pull/528
* typo fix by @jiangying000 in https://github.com/rust-lang/log/pull/529
* Remove dependency on cfg_if by @EriKWDev in https://github.com/rust-lang/log/pull/536
* GitHub Workflows security hardening by @sashashura in https://github.com/rust-lang/log/pull/538
* Fix build status badge by @atouchet in https://github.com/rust-lang/log/pull/539
* Add call_logger to the documentation by @a1ecbr0wn in https://github.com/rust-lang/log/pull/547
* Use stable internals for key-value API by @KodrAus in https://github.com/rust-lang/log/pull/550
* Change wording of list of implementations by @Thomasdezeeuw in https://github.com/rust-lang/log/pull/553
* Add std-logger to list of implementations by @Thomasdezeeuw in https://github.com/rust-lang/log/pull/554
* Add `set_max_level_racy` and gate `set_max_level` by @djkoloski in https://github.com/rust-lang/log/pull/544
* [doc] src/lib.rs : prefix an unused variable with an underscore by @OccupyMars2025 in https://github.com/rust-lang/log/pull/561
* [doc] src/macros.rs :  correct  grammar errors of an example in lib documentation by @OccupyMars2025 in https://github.com/rust-lang/log/pull/562

## [0.4.17] - 2022-04-29

* Update `kv_unstable` internal dependencies.

## [0.4.16] - 2022-03-22

* Fix a conflict with unqualified `Option` use in macros.

## [0.4.15] - 2022-02-23

* Silence a warning about the deprecated `spin_loop_hint`.
* Relax ordering in the atomic `set_max_level` call.
* Add thumbv4t-none-eabi to targets that don't support atomics
* Allow levels to be iterated over.
* Implement `Log` on some common wrapper types.
* Improvements to test coverage.
* Improvements to documentation.
* Add key-value support to the `log!` macros.
* Tighten `kv_unstable` internal dependencies, so they don't bump past their current alpha.
* Add a simple visit API to `kv_unstable`.
* Support `NonZero*` integers as values in structured logging
* Support static strings as keys in structured logging

## [0.4.14] - 2021-01-27

* Remove the `__private_api_log_lit` special case.
* Fixed incorrect combination of `kv_unstable` and `std` features causing compile failures.
* Remove unstable `Value::to_*` conversions that were incorrectly using `as`.
* Rename unstable `Value::to_error` to `Value::to_borrowed_error`.

## [0.4.13] - 2021-01-11

* This is the same as `0.4.11`, except with a `kv_unstable_std` feature added to aid migrating current dependents to `0.4.14` (which was originally going to be `0.4.13` until it was decided to create a patch from `0.4.11` to minimize disruption).

## [0.4.12] - 2020-12-24

### New

* Support platforms without atomics by racing instead of failing to compile
* Implement `Log` for `Box<T: Log>`
* Update `cfg-if` to `1.0`
* Internal reworks of the structured logging API. Removed the `Fill` API
and added `source::as_map` and `source::as_list` to easily serialize a `Source`
as either a map of `{key: value, ..}` or as a list of `[(key, value), ..]`.

### Fixed

* Fixed deserialization of `LevelFilter` to use their `u64` index variants

## [0.4.11] - 2020-07-09

### New

* Support coercing structured values into concrete types.
* Reference the `win_dbg_logger` in the readme.

### Fixed

* Updates a few deprecated items used internally.
* Fixed issues in docs and expands sections.
* Show the correct build badge in the readme.
* Fix up a possible inference breakage with structured value errors.
* Respect formatting flags in structured value formatting.

## [0.4.10] - 2019-12-16 (yanked)

### Fixed

* Fixed the `log!` macros, so they work in expression context (this regressed in `0.4.9`, which has been yanked).

## [0.4.9] - 2019-12-12 (yanked)

### Minimum Supported Rust Version

This release bumps the minimum compiler version to `1.31.0`. This was mainly needed for `cfg-if`,
but between `1.16.0` and `1.31.0` there are a lot of language and library improvements we now
take advantage of.

### New

* Unstable support for capturing key-value pairs in a record using the `log!` macros

### Improved

* Better documentation for max level filters.
* Internal updates to line up with bumped MSRV

## [0.4.8] - 2019-07-28

### New

* Support attempting to get `Record` fields as static strings.

## [0.4.7] - 2019-07-06

### New

* Support for embedded environments with thread-unsafe initialization.
* Initial unstable support for capturing structured data under the `kv_unstable`
feature gate. This new API doesn't affect existing users and may change in future
patches (so those changes may not appear in the changelog until it stabilizes).

### Improved

* Docs for using `log` with the 2018 edition.
* Error messages for macros missing arguments.

## [0.4.6] - 2018-10-27

### Improved

* Support 2018-style macro import for the `log_enabled!` macro.

## [0.4.5] - 2018-09-03

### Improved

* Make `log`'s internal helper macros less likely to conflict with user-defined
  macros.

## [0.4.4] - 2018-08-17

### Improved

* Support 2018-style imports of the log macros.

## [0.4.3] - 2018-06-29

### Improved

* More code generation improvements.

## [0.4.2] - 2018-06-05

### Improved

* Log invocations now generate less code.

### Fixed

* Example Logger implementations now properly set the max log level.

## [0.4.1] - 2017-12-30

### Fixed

* Some doc links were fixed.

## [0.4.0] - 2017-12-24

The changes in this release include cleanup of some obscure functionality and a more robust public
API designed to support bridges to other logging systems, and provide more flexibility to new
features in the future.

### Compatibility

Vast portions of the Rust ecosystem use the 0.3.x release series of log, and we don't want to force
the community to go through the pain of upgrading every crate to 0.4.x at the exact same time. Along
with 0.4.0, we've published a new 0.3.9 release which acts as a "shim" over 0.4.0. This will allow
crates using either version to coexist without losing messages from one side or the other.

There is one caveat - a log message generated by a crate using 0.4.x but consumed by a logging
implementation using 0.3.x will not have a file name or module path. Applications affected by this
can upgrade their logging implementations to one using 0.4.x to avoid losing this information. The
other direction does not lose any information, fortunately!

**TL;DR** Libraries should feel comfortable upgrading to 0.4.0 without treating that as a breaking
change. Applications may need to update their logging implementation (e.g. env-logger) to a newer
version using log 0.4.x to avoid losing module and file information.

### New

* The crate is now `no_std` by default.
* `Level` and `LevelFilter` now implement `Serialize` and `Deserialize` when the `serde` feature is
    enabled.
* The `Record` and `Metadata` types can now be constructed by third-party code via a builder API.
* The `logger` free function returns a reference to the logger implementation. This, along with the
    ability to construct `Record`s, makes it possible to bridge from another logging framework to
    this one without digging into the private internals of the crate. The standard `error!` `warn!`,
    etc., macros now exclusively use the public API of the crate rather than "secret" internal APIs.
* `Log::flush` has been added to allow crates to tell the logging implementation to ensure that all
    "in flight" log events have been persisted. This can be used, for example, just before an
    application exits to ensure that asynchronous log sinks finish their work.

### Removed

* The `shutdown` and `shutdown_raw` functions have been removed. Supporting shutdown significantly
    complicated the implementation and imposed a performance cost on each logging operation.
* The `log_panics` function and its associated `nightly` Cargo feature have been removed. Use the
    [log-panics](https://crates.io/crates/log-panics) instead.

### Changed

* The `Log` prefix has been removed from type names. For example, `LogLevelFilter` is now
    `LevelFilter`, and `LogRecord` is now `Record`.
* The `MaxLogLevelFilter` object has been removed in favor of a `set_max_level` free function.
* The `set_logger` free functions have been restructured. The logger is now directly passed to the
    functions rather than a closure which returns the logger. `set_logger` now takes a `&'static
    Log` and is usable in `no_std` contexts in place of the old `set_logger_raw`. `set_boxed_logger`
    is a convenience function which takes a `Box<Log>` but otherwise acts like `set_logger`. It
    requires the `std` feature.
* The `file` and `module_path` values in `Record` no longer have the `'static` lifetime to support
    integration with other logging frameworks that don't provide a `'static` lifetime for the
    equivalent values.
* The `file`, `line`, and `module_path` values in `Record` are now `Option`s to support integration
    with other logging frameworks that don't provide those values.

### In the Future

* We're looking to add support for *structured* logging - the inclusion of extra key-value pairs of
    information in a log event in addition to the normal string message. This should be able to be
    added in a backwards compatible manner to the 0.4.x series when the design is worked out.

## Older

Look at the [release tags] for information about older releases.

[Unreleased]: https://github.com/rust-lang-nursery/log/compare/0.4.33...HEAD
[0.4.32]: https://github.com/rust-lang/log/compare/0.4.32...0.4.33
[0.4.32]: https://github.com/rust-lang/log/compare/0.4.31...0.4.32
[0.4.31]: https://github.com/rust-lang/log/compare/0.4.30...0.4.31
[0.4.30]: https://github.com/rust-lang/log/compare/0.4.29...0.4.30
[0.4.29]: https://github.com/rust-lang/log/compare/0.4.28...0.4.29
[0.4.28]: https://github.com/rust-lang/log/compare/0.4.27...0.4.28
[0.4.27]: https://github.com/rust-lang/log/compare/0.4.26...0.4.27
[0.4.26]: https://github.com/rust-lang/log/compare/0.4.25...0.4.26
[0.4.25]: https://github.com/rust-lang/log/compare/0.4.24...0.4.25
[0.4.24]: https://github.com/rust-lang/log/compare/0.4.23...0.4.24
[0.4.23]: https://github.com/rust-lang/log/compare/0.4.22...0.4.23
[0.4.22]: https://github.com/rust-lang/log/compare/0.4.21...0.4.22
[0.4.21]: https://github.com/rust-lang/log/compare/0.4.20...0.4.21
[0.4.20]: https://github.com/rust-lang-nursery/log/compare/0.4.19...0.4.20
[0.4.19]: https://github.com/rust-lang-nursery/log/compare/0.4.18...0.4.19
[0.4.18]: https://github.com/rust-lang-nursery/log/compare/0.4.17...0.4.18
[0.4.17]: https://github.com/rust-lang-nursery/log/compare/0.4.16...0.4.17
[0.4.16]: https://github.com/rust-lang-nursery/log/compare/0.4.15...0.4.16
[0.4.15]: https://github.com/rust-lang-nursery/log/compare/0.4.13...0.4.15
[0.4.14]: https://github.com/rust-lang-nursery/log/compare/0.4.13...0.4.14
[0.4.13]: https://github.com/rust-lang-nursery/log/compare/0.4.11...0.4.13
[0.4.12]: https://github.com/rust-lang-nursery/log/compare/0.4.11...0.4.12
[0.4.11]: https://github.com/rust-lang-nursery/log/compare/0.4.10...0.4.11
[0.4.10]: https://github.com/rust-lang-nursery/log/compare/0.4.9...0.4.10
[0.4.9]: https://github.com/rust-lang-nursery/log/compare/0.4.8...0.4.9
[0.4.8]: https://github.com/rust-lang-nursery/log/compare/0.4.7...0.4.8
[0.4.7]: https://github.com/rust-lang-nursery/log/compare/0.4.6...0.4.7
[0.4.6]: https://github.com/rust-lang-nursery/log/compare/0.4.5...0.4.6
[0.4.5]: https://github.com/rust-lang-nursery/log/compare/0.4.4...0.4.5
[0.4.4]: https://github.com/rust-lang-nursery/log/compare/0.4.3...0.4.4
[0.4.3]: https://github.com/rust-lang-nursery/log/compare/0.4.2...0.4.3
[0.4.2]: https://github.com/rust-lang-nursery/log/compare/0.4.1...0.4.2
[0.4.1]: https://github.com/rust-lang-nursery/log/compare/0.4.0...0.4.1
[0.4.0]: https://github.com/rust-lang-nursery/log/compare/0.3.8...0.4.0
[release tags]: https://github.com/rust-lang-nursery/log/releases

Գրաֆիտի („գրաֆիտո“ լատիներեն նշանակում է «քերթել»), այս բառով բնորոշվել են մարդկային առաջին նկարչական քայլերը, այսինքն՝ մարդու նախնիների կողմից քարով քերթված պատկերները քարանձավների պատերին, որտեղ պատկերված էին որսի դրվագներ, կենդանիների և մարդկանց նկարներ և այլն։

Ինչպես և որտեղ է ստեղծվել 

Այժմեական մշակույթում Գրաֆիտի անվանում են փողոցային պատերին արված պատկերները, հաճախ անվանելով նաև վանդալիստական ակտ, քանի-որ այդ կերպ արտահայտելով իրենց մտքերը, նկարիչները նաև խախտում են շինության ընդհանուր տեսքը, ինչևէ մարդկանց կարծիքները բազում է այս երիտասարդ մշակույթի վերաբերյալ։ Իսկապես լինում են միանշանակ վանդալիստական ակտեր Գրաֆիտիի միջոցով, բայց և ստեղծվում են իսկապես հարգանքի արժանի արվեստի գործեր, որոնց հեղինակների յուրօրինակ աշխատանքը տեսնելով, դժվար է դասել նրանց վանդալիստների շարքերում։

Գրաֆիտի նկարողներին անվանում են վրայթեռներ, անգլերեն writer, որը նշանակում է գրող, իսկ քանի որ գրաֆիտին հիմնականում լինում է ինչ-որ բառի տեսքով, ապա նկարչին էլ անվանում են գրող։

Այսօրվա գրաֆիտին ստեղծվել է 1960-ականներին Ամերիկայի Միացյալ Նահանգներում, ի սկզբանե այն ունեցել է բավականին մռայլ իմաստ։ Փողոցային հանցագործ միավորումները, գրելով սեփական միավորման անունը պատերին, նշել են այն բոլոր տարածքները, որտեղ ըստ իրենց դրված օրենքների պետք է գործեն իրենք, այդ կերպ պայմանավորվածություն ստեղծելով այլ միավորումների հետ համատեղ քաղաքի բաժանման համար։ Իհարկե այս առանձնահատման ձևը նաև օգնել է օրինապահ ուժերին, իրենց ի դեմս հանցագործների պայքարի մեջ և Գրաֆիտին դարձել է ոչ օգտակար ձև նշվելու հանցագործների համար, այն հետզհետե դարձել է ավելի վանդալիզմի նման երևույթ, իսկ իր զարգացման ընթացքում նաև ստանալով նոր որակ և երիտասարդության կողմից այլ տեսակետից նայվելով դարձել է տեխնիկապես բարդ և նույնիսկ կոմերցիոն արժեք ունեցող նկարչական ուղղություն։

Գրաֆիտին թերևս չի համարվում պրոֆեսիոնալ նկարչական ոճ, բայց մեծ համբավ ունի երիտասարդության և հասուն մարդկանց շրջանակներում, այդ պատճառով բավարարվում է ինքնազարգացմամբ, որն իսկապես աշխատում է ազատամտության և էնտուզիազմի հաշվին։ Այսօր գրաֆիտին ոչ միայն նկարչական նշանակություն ունի, այլ նաև իմաստավոր, քանի որ երիտասարդությունը շատ հաճախ պատերին նկարված պատկերների և բառերի միջոցով անդրադառնում է իրեն հուզող հարցերին, օրինակ 2004 թվականին նկատվել են բազում նկարազարդված պատեր ամբողջ աշխարհում նկարված Իրաքյան պատերազմի թեմատիկայով։

Գրաֆիտիի ոճերը 
Գրաֆիտին, չնայած իր բավականին նոր ուղղություն լինելու հանգամանքին, ունի մի շարք ոճեր. Դրանք են՝ Բաբլ սթայլ (Bubble style), Սթրիթ սթայլ (Street style), Քերեքթր (Character), Էֆեքս (FX)։

Բաբլ սթայլ 
(Bubble style), Bubble՝ նշանակում է փուչիկ, style՝ ոճ, այսինքն փուչիկային ոճ, երևի արդեն պարզ է թէ ինչպիսին կլինի այս ոճի տեսքը։ Գրաֆիտիի այս ձևը տեխնիկապես ամենահեշտն է և համբավ ունի սկսնակ նկարողների՝ ռայթեռների մոտ, այն իր նկարչական մոտեցումով ավելի նման է մուլտիպլիկացիոն տառատեսակի, քանի որ Բաբլ ստայլով նկարվում են միայն բառեր։

Սթրիթ սթայլ 
(Street style), այսինքն փողոցային ոճ։ Այս ոճը համեմատաբար ավելի տեխնիկապես բարդ է և համարվում է ամենասիրված ոճը, այն նաև ամենատարածվածն է։ Այս ոճով նկարվում են միայն բառեր, որոնք հաճախ այնքան խճճված են պատկերվում, որ միայն հեղինակն է ի վիճակի կարդալ։ Հիմնականում պետք էլ չէ հասկանալ պատին գրվածը, քանի որ հեղինակը ամենայն հավանականությամբ սեփական մականունն է գրում, այդպես է ընդունված այս ոճում, քանի որ շեշտը դրված է ոչ թէ բառի իմաստի վրա, այլ նրա գեղարվեստական հարստության, գույնի և ֆորմայի գեղեցկության վրա։ Չնայած նրան որ այս գրաֆիտիները անհասկանալի են կարդացողի համար, հաճախ հանդիպում են այնպիսի նմուշներ, որոնց նայողը երկար չի կարողանում պոկ գալ։

Քերեքթըր 

(Character), այսինքն կերպար։ Այս ոճին հավատարիմ նկարիչները պատկերում են մարդկային դիմանկարներ, կամ կենդանիների, մի խոսքով ամեն ինչ կապված կերպարվեստի հետ, հաճախ հանդիպում են պատեր հայտնի մարդկանց դիմանկարներով, օրինակ քսաներորդ դարի վերջին շատ մոդայիկ էր 2Pac-ի և Չե Գեվարայի դիմանկարները, որոնք ասես տպվում էին մեկը մյուսի հետևից։

Էֆեքս 

(FX), FX-ը effects անգլերեն բառի սլենգային գրվածքն է, գտնելով որ այդ բառը գրել այնպես ինչպես այն հնչում է ավելի մոտ է Գրաֆիտիի կոնցեպտին այն այդպես էլ գրում են, հայտնի է այս ոճը նաև Մյուրալիզմ անվանումով, որն օգտագործվում է հիմնականում Եվրոպայում, քանի-որ շատերի կարծիքով այն սկիզբ է առել Ֆրանսիայում։ Այս ոճը տեխնիկապես և իր բնույթով ամենադժվարն է, քանզի այստեղ պահանջվում է արդեն տարիների փորձ և գեղարվեստական բացառիկ որակ։ ԱՄՆ-ում և Եվրոպայում այս ուղղությունը մեծ համբավ ունի սրճարանների, ակումբների և նույնիսկ գրասենյակների ձևավորման ասպարեզում և վարձատրվում է մեծ գումարներով։ Լինում են դեպքեր, երբ նաև վաճառվում են կտավի վրա, ինչպես կվաճառվեր գեղանկարը, դա խոսում է որակի և բարդ մասնագիտական աշխատանքի մասին։ Աշխարհում շատ քիչ գրաֆիտիի մասնագետներ կան, որոնք նկարում են այս ոճով, հիմնականում նրանց տարիքն անցնում է երեսունը, իսկ սկսել են նրանք տասնչորս-տասնհինգ տարեկանից, ինչը խոսում է փորձի մասին։ Այս ոճից է սկիզբ առել աերոգրաֆիան, որը նման ոճի նկարչություն է միայն մեքենաների վրա։

Գրաֆիտիի ժամանակակից արքաներից են՝ Loomit, Daim, Codeak,Seen,Cope և այլք։ Հայաստանում նույնպես կան ռայթեռներ, նրանցից են՝ Free Art, Van, Ray, Toxic, և այլք։ Կան նաև անհատական նկարողներ, որոնցից առավել հայտնին Հայաստանում Key անունով երիտասարդն է։

Գեղանկարչություն
Արվեստի ժանրեր

#![allow(dead_code, unused_imports)]

use log::{debug, error, info, trace, warn, Level, LevelFilter, Log, Metadata, Record};
use std::sync::{Arc, Mutex};

struct State {
    last_log_level: Mutex<Option<Level>>,
    last_log_location: Mutex<Option<u32>>,
}

struct Logger(Arc<State>);

impl Log for Logger {
    fn enabled(&self, _: &Metadata) -> bool {
        true
    }

    fn log(&self, record: &Record) {
        *self.0.last_log_level.lock().unwrap() = Some(record.level());
        *self.0.last_log_location.lock().unwrap() = record.line();
    }
    fn flush(&self) {}
}

#[test]
fn test_integration() {
    // These tests don't really make sense when static
    // max level filtering is applied
    #[cfg(not(any(
        feature = "max_level_off",
        feature = "max_level_error",
        feature = "max_level_warn",
        feature = "max_level_info",
        feature = "max_level_debug",
        feature = "max_level_trace",
        feature = "release_max_level_off",
        feature = "release_max_level_error",
        feature = "release_max_level_warn",
        feature = "release_max_level_info",
        feature = "release_max_level_debug",
        feature = "release_max_level_trace",
    )))]
    {
        let me = Arc::new(State {
            last_log_level: Mutex::new(None),
            last_log_location: Mutex::new(None),
        });
        let a = me.clone();
        let logger = Logger(me);

        test_filter(&logger, &a, LevelFilter::Off);
        test_filter(&logger, &a, LevelFilter::Error);
        test_filter(&logger, &a, LevelFilter::Warn);
        test_filter(&logger, &a, LevelFilter::Info);
        test_filter(&logger, &a, LevelFilter::Debug);
        test_filter(&logger, &a, LevelFilter::Trace);

        test_line_numbers(&logger, &a);
    }
}

fn test_filter(logger: &dyn Log, a: &State, filter: LevelFilter) {
    // tests to ensure logs with a level beneath 'max_level' are filtered out
    log::set_max_level(filter);
    error!(logger: logger, "");
    last(a, t(Level::Error, filter));
    warn!(logger: logger, "");
    last(a, t(Level::Warn, filter));
    info!(logger: logger, "");
    last(a, t(Level::Info, filter));
    debug!(logger: logger, "");
    last(a, t(Level::Debug, filter));
    trace!(logger: logger, "");
    last(a, t(Level::Trace, filter));

    fn t(lvl: Level, filter: LevelFilter) -> Option<Level> {
        if lvl <= filter {
            Some(lvl)
        } else {
            None
        }
    }
    fn last(state: &State, expected: Option<Level>) {
        let lvl = state.last_log_level.lock().unwrap().take();
        assert_eq!(lvl, expected);
    }
}

fn test_line_numbers(logger: &dyn Log, state: &State) {
    log::set_max_level(LevelFilter::Trace);

    info!(logger: logger, ""); // ensure check_line function follows log macro
    check_log_location(state);

    #[track_caller]
    fn check_log_location(state: &State) {
        let location = std::panic::Location::caller().line(); // get function calling location
        let line_number = state.last_log_location.lock().unwrap().take().unwrap(); // get location of most recent log
        assert_eq!(line_number, location - 1);
    }
}

Geocaching (anglicky , v češtině také často ) je hra na pomezí sportu a turistiky, která spočívá v použití navigačního globálního družicového polohového systému při hledání skryté schránky nazývané cache (v češtině psáno i keš), o níž jsou známy její zeměpisné souřadnice. Při hledání se používají turistické navigační přístroje či chytré telefony. Člověk zabývající se geocachingem bývá označován slovem geocacher, česky též geokačer nebo prostě kačer. Po objevení cache, zapsání se do logbooku (deníku) a případné výměně obsahu ji nálezce opět uschová a zamaskuje.

Všeobecně oceňovaným prvkem geocachingu je umisťování keší na místech, která jsou něčím zajímavá a přesto nejsou turisticky navštěvovaná. V popisu cache (listing) jsou pak uvedeny informace o místě s jeho zvláštnostmi a zajímavostmi. Cache se ale umisťují i do zajímavých míst velmi frekventovaných. V některých případech je zajímavým právě úkol, který je s nalezením cache spojen.

V současnosti (2020) existují přibližně 3 miliony keší ve 191 zemích světa, na všech kontinentech včetně Antarktidy. Ve světě existuje více než 200 geocacherských organizací.

Cache 

Cache bývá voděvzdorná, většinou plastová schránka, kanystr, apod. Zakladatel cache (owner – majitel) po jejím umístění zveřejní její souřadnice na některý internetový server zabývající se geocachingem. Schránka by měla být dostatečně veliká, aby se do ní vešel deník (tzv. logbook), do něhož se zapisují její nálezci. Bývá zvykem umísťovat do cache také nějaké předměty na výměnu. Nálezce cache si smí takový předmět vzít (a například přenést do další cache), ale musí místo něj vložit něco vlastního (jiný předmět) pro další účastníky hry, o stejné nebo vyšší hodnotě.

Pravidla 
Cache musí být od sebe vzdálené minimálně 0,1 míle, což je 161 metrů. Keše schvaluje a publikuje reviewer. Revieweři jsou dobrovolníci, kteří mají na starost publikování keší ve stanoveném území. Umístění keše musí dodržovat veškeré místní zákony, na soukromém majetku vyžadují souhlas majitele objektu. Dle regionálních pravidel v Česku se nesmějí zakládat na hřbitovech, dětských hřištích, základních a mateřských školách, nesmějí být zakopané hluboko pod zemí, ve vojenských prostorech atd.

Obsah cache 
Schránka by měla vždy obsahovat alespoň logbook a informaci pro náhodné nálezce („mudlokarta“). Schránka (nebo alespoň logbook) by měla být jednoznačně označena názvem cache.

Vhodným doplňkem základního obsahu cache je pak ještě tužka, uzavíratelný plastový sáček pro vodotěsné uložení logbooku a tužky a náhradní plastový sáček pro zabalení schránky (pokud je schránka od zakladatele takovým sáčkem opatřena).

Logbook, mudlokarta, vlastní schránka, obal, tužka, případně ořezávátko je stálou součástí cache, a nesmí se z ní odnášet, ani výměnou za jiné předměty!

Pokud to rozměry schránky cache dovolí, může zakladatel cache přiložit drobné předměty na výměnu, nebo trackovatelné předměty (TB nebo GC – viz níže).

Pokud nálezce v cache neobjeví žádný předmět na výměnu, nebo se mu žádný nelíbí, nemusí si jej vzít. Může v cache ale zanechat jiný takový drobný předmět. Rozhodně by si ale neměl vzít žádný předmět z cache, aniž by do cache jiný předmět o stejné nebo vyšší hodnotě výměnou vložil. Celková hodnota obsahu cache se nesmí výměnou snížit. Vhodnost konkrétních předmětů pro vložení do cache je dána jednak velikostí schránky, ale také představou, že nejčastějšími geocachery, kteří se na výměnu těší, jsou malé děti. Naprosto nevhodné jsou tedy předměty jako peníze (s výjimkou symbolických platných mincí jako např. jednotlivé mince cizích měn), cigarety, plynové zapalovače, předměty s nemravným vyobrazením apod. Nepřípustné je vkládání jakýchkoliv potravin (žvýkačky, sušenky, bonbony…).

Speciální předměty v cache 

V keších je možné nalézt i speciální trasovatelné předměty. Jsou to buď Travel Bugy (udávána mezinárodní zkratka TB, označováno jako TBxxxxx) – předměty opatřené speciální kovovou známkou s unikátním identifikačním kódem, nebo geocoiny (udávána mezinárodní zkratka GC, nebo též počeštěně geomince) – speciální mince s unikátním identifikačním kódem. Každý takový předmět má svůj úkol (anglicky current goal), který je uveden na serveru nebo přímo u travelbugu či geomince na kartičce či jiném prvku. Current goal obsahuje zpravidla cestovní cíl travelbugu či geomince (např. „docestovat do Japonska“), nebo jiné přání ownera (např. „travelbug musí přebývat v keších blízko vody“). Pro travelbug se užívá také zkratka TB a pro geocoin GC.

Pokud nalezená cache obsahuje TB nebo GC, může se geocacher rozhodnout, zda předmět (nemusí být výměnou za jiný předmět) z cache odnese (a pokusí se splnit či pomoci splnit jeho úkol co nejrychlejším přenesením do další cache podle jeho „current goal“), nebo zda si TB resp. GC pouze prohlédne (a poznamená jeho unikátní kód pro pozdější registraci na serveru). Nemusí však volit žádnou z těchto možností a tyto předměty může ignorovat.

Kromě TB a GC, registrovatelnými na serveru Geocaching.com, se občas objevují i jiné trasovatelné předměty. Tyto jsou ale trasovatelné pomocí jiných serverů (např. geokrety.org, www.geotrackables.com, www.geolutins.com). Tyto aktivity jsou zpravidla organizované jednotlivci nespokojenými se skutečností, že s pořízením TB či GC je nutné (kromě výrobní ceny geocoinů) zaplatit drobný poplatek (jednotky dolarů) určený k financování provozu serveru.

Geocacher, který chce být majitelem TB či GC (a s určením nějakého „current goal“ jej vložit do nějaké cache), má možnost je získat pomocí některého z mnoha internetových obchodů zaměřených výhradně na prodej tohoto typu zboží a jiných doplňkových „geocaching“ předmětů (turistických navigačních přístrojů, oblečení, plastových schránek apod.)

Typy skrýší (caches)

Podle velikosti 

 Nano – nejmenší schránka. Nevejde se do ní tužka a většinou obsahuje pouze „logbook“, který je i tak velmi malý (příkladem může být i GeoKnots Logsheet Roller). Tato velikost nemá podporu na geocaching.com, proto jsou keše této velikosti uváděny buďto jako Micro nebo Other.
 Micro – velmi malá schránka (podle pravidel menší než cca 1 dl, tzn. patří sem i tzv. „nano-cache“). Typicky lehce upravená a přizpůsobená krabička od filmu, od bonbonů tic-tac, od léků apod. Často je také používán prefabrikát PET lahví. Pro její možnost umístit ji nenápadně i do frekventovaných prostor se používá nejčastěji pro keše v centrech měst apod. Micro-cache bývá doplněna magnetem pro snadnější uchycení na kovových konstrukcích a bývá i velmi umně maskována tak, aby co nejlépe splynula s okolím. Pro svoji miniaturní velikost se do micro-cache zpravidla nemohou vkládat žádné předměty na výměnu, ale téměř výhradně pouze logbook a případně tužka.
 Malá – malá schránka, přibližně o objemu malé krabice na ohřívání potravin v mikrovlnné troubě, která se také jako schránka často používá. Small-cache obsahuje logbook a menší předměty na výměnu.
 Střední – schránka běžné velikosti, vejdou se do ní kromě logbooku i větší předměty na výměnu, malé plyšové hračky apod. Často se pro ni používají běžné krabice na ohřívání potravin v mikrovlnné troubě.
 Velká – specializované výjimečné schránky, jejichž nadměrná velikost bývá zaměřena speciálně pro ukládání větších předmětů na výměnu (např. knih a CD).
 Other – schránka neurčitelné velikosti. Může to být například placatá magnetická nálepka nebo kniha v knihovně. Nově se touto velikostí označují i earthcache a eventy.

Podle charakteru 
 Tradiční cache (český výraz tradička) – schránka je umístěna přímo na místě definovaném souřadnicemi zveřejněnými registrovaným členům.
 Multi cache – k nalezení cílové (tzv. finální) skrýše je potřeba nalézt nejprve skrýš první (či splnit úkol či vyluštit šifru) danou zveřejněnými souřadnicemi a z informací získaných v první skrýši nalézt skrýš finální, případně druhou, třetí a další, postupně je nutné se propracovat až na tzv. finální skrýš. Multi cache mohou mít mnoho podob, spojuje je ale shodná filosofie postupného hledání řetězce pomocných skrýší nebo plnění úkolů směřujících k nalezení skrýše hlavní. Jednotlivé pomocné skrýše se nazývají stage (z angl. stage, tj. stupeň).
 Mystery cache (český výraz mysterka) – zveřejněné souřadnice ukazují zpravidla do blízkého okolí cache, ale skutečné souřadnice musí geocacher dopředu získat například prostudováním nějakých informací, vyluštěním hádanky, šifry apod. Někdy se též tato cache nazývá unknown (tj. neznámá).
 Webcam cache (český výraz webka) – speciální cache, která neobsahuje ukrytou schránku, ale přivede geocachera před objektiv konkrétní popsané webkamery. K virtuálnímu „odlovení cache“ pak stačí, aby jiná osoba snímek z webkamery dostupný na internetu uložila. Geocacher pak uložený snímek přiloží jako důkaz k elektronickému logu cache. Nové webcam cache již nelze od konce roku 2005 na serveru Geocaching.com zakládat.
 Letterbox hybrid – Kombinace geocachingu a starší hry letterboxing. Hledání skrýše probíhá jen z části pomocí navigačního přístroje; z části pak podle různých indicií (např. slovní popis cesty, fotografie). Oproti tradiční cache obsahuje navíc razítko, které si nálezce může otisknout do svého deníčku.
 Virtuální cache (český výraz virtuálka) – na zadaných souřadnicích není ukryta žádná skutečná schovaná schránka. Geocacher musí na hledaném místě něco zjistit (např. jména na pomníku apod.) a odeslat tyto informace ownerovi cache pro uznání logu. Tyto cache již není možné na geocaching.com zakládat, ale je možné je stále hledat. V srpnu 2017 dostalo 4000 geokačerů možnost založit novou virtuální kešku. Hráči s touto možností byli vybráni pomocí speciálního algoritmu, který hodnotil například kvalitu jimi založených kešek. Dále byli takto „odměněni“ hráči významně se podílející na chodu geocachingu. Tito hráči mohou svoji odměnu v podobě založení nové virtuálky uplatnit až do srpna 2018.
 Earthcache (český výraz earthka) – obdoba virtuálních keší. Earthcache se zakládá v místech s geologickou či jinou zajímavostí týkající se planety Země. Podobně jako u virtuálních cachí není úkolem najít cache, ale dojít na dané místo, zjistit nějaké informace, udělat fotografie atd. Vždy záleží na zakladateli, jaké podmínky pro uznání logu stanoví.
 Event cache – setkání geocacherů. Společenská událost spojená např. s určitým programem (např. CITO). Na setkání může dojít k hromadné výměně travelbugů nebo geocoinů. Opravdu velká setkání mohou být za určitých podmínek označena jako Mega Event. V srpnu 2014 se konal v Mnichově i první Giga Event. V České republice se první Giga Event konal ve dnech 1.–3. 9. 2017 na Plumlově. Zároveň šlo o jediný Giga Event v roce 2017 na světě. Na Mega Eventech a Giga eventech jsou také Lab Cache, kešky u nichž je třeba zadat kód
 Cache In Trash Out Event (CITO) – setkání (event), na kterém se geocacheři snaží vyčistit vybrané území od nepořádku a odpadků, které v přírodě ponechali lhostejní lidé. Je to společenské setkání spojené s ekologickým chováním geocacherů k přírodě.
 Wherigo cache (český výraz wigo) – spojení geocachingu a hry wherigo. Od klasického wheriga se liší jen tím, že na konci cesty je keška.
 Members Only Cache (prémiové kešky) – každý typ keše s výjimkou eventů, megaeventů, gigaeventů, lab keší a CITO eventů může být dostupný jen pro prémiové členy

Podle obtížnosti a terénu 
S růstem popularity a dostupnosti geocachingu vznikla mezi částí geocacherů touha po větší exkluzivitě – touha po hledání geocache (tzv. kešek), které nedokáže dosáhnout každý a s jejichž odlovem je často spojena určitá míra adrenalinu, případně i obtížné luštění šifer. Tento typ kešky je některými geocachery nazýván drsnokeš. Možné umístění zahrnuje skály, přírodní i městské podzemí, nedostupné stromy atd. Tyto složitě dostupné kešky se v geocachingovém slangu označují jako tépětky (T5; mají nejvyšší terénní obtížnost – vyjádřenou stupněm 5).

Každá keš má číselně označený terén a obtížnost. Škála je po polovinách celých čísel od 1 do 5.

Server Geocaching.com 
Nejstarší a nejvíce využívaný server je geocaching.com, provozovaný společností Groundspeak v USA v Seattle. Server umožňuje registrovaným uživatelům prohlížet
cache na libovolném místě po celém světě. Také si zde uživatel vede svůj online log, do kterého si zapisuje nálezy. Kromě některých soukromých údajů jsou veškerá data (logy, fotografie, osobní statistiky) přístupná všem registrovaným uživatelům serveru. Každý tak může sledovat nejen vlastní nálezy jednotlivých cache, ale najít si i statistiky nálezů jiných lovců.

Server také umožňuje sledování trasovatelných předmětů, takže lze získat informace o „current goal“ nalezeného TB či GC, stejně tak i o historii putování či aktuální pozici konkrétního TB či GC.

Alternativní servery 

Přístup provozovatele serveru Geocaching.com se časem přestal líbit některým jeho uživatelům, kteří se začali sdružovat k provozování vlastních variant hry. Jestliže se např. TerraCaching zaměřuje na vysokou kvalitu keší a neumožňuje registraci keše zároveň na jiných serverech (tzv. double-listing), Opencaching Network volně sdružující jednotlivé národní projekty, dává důraz na maximální otevřenost, komunitnost a nekomerčnost (tzv. double-listing je zde dovolen, ale není doporučován). V roce 2010 pak vznikl projekt OpenCaching.com, který (spolu s důrazem na jednoduchost) deklaroval podobné cíle jako projekty sdružené v Opencaching Network (otevřenost, komunitnost, nekomerčnost), ale na rozdíl od těchto nezávislých projektů byl OpenCaching.com provozován a řízen firmou Garmin, populárním výrobcem turistických navigací. Dne 21. srpna 2015 Garmin oznámil ukončení provozu OpenCaching.com.

České servery 
K 15. výročí Geocachingu (2. května 2015) byl spuštěn oficiální Průvodce Geocachingem na webu kesky.cz, který přehledně zpracovává jednotlivé tematické okruhy v českém jazyce – základy Geocachingu, hledání keší, zakládání keší, eventy, trackovatelné předměty, aplikace pro Geocaching a výbava pro Geocaching. Průvodce navíc zahrnuje aktuální přehled plánovaných geocachingových akcí (eventů) na území České republiky.

Největším diskuzním serverem české komunity geocacherů je server Geocaching.cz, obsahující diskusní fórum českých geocacherů s mnoha tématy, informace o zajímavých programech, webech, chystaných setkáních apod. Dále existuje i několik regionálních serverů pro Plzeň (Geocaching Community Plzeň), Brno (K. G. Brno), Olomouc (Olomoucké geokačerstvo), jižní Čechy (Geojih – Geocaching na jihu Čech), západní Čechy (Geowest), Beskydy a Ostravu (BO!!!GEO – Beskydsko-Ostravský geocaching), či Kladensko a okolí (GeoKladno).

Existuje také Česká asociace geocachingu (tzv. ČAGeo) sídlící v Chrastavě (dříve v Horoměřicích), jedná se o občanské sdružení, které není nijak spojeno s provozovatelem hry. Má ve svých stanovách určen jako cíl zlepšení úrovně geocachingu v České republice. Její největší úspěch je organizace eventu MAZE a první uvedení nového typu kešek Lab Cache (obě mají vlastní ikonu). Čageo často vyvolává rozporuplné reakce zejména svými prvními kroky, podle diskusí na fóru www.geocaching.cz.

Alternativní proudy geocachingu jsou v Česku zastoupeny serverem 'OpenCaching.com' a českou verzí 'Opencaching.cz'. Zdá se, že obě tyto alternativy jsou prozatím z nejrůznějších důvodů na okraji zájmu české geocacherské komunity. Zatímco Opencaching.cz (vzniklý v r. 2006 jako reakce na komerční základ některých služeb na Geocaching.com) v polovině roku 2012 hlásil 400 aktivních keší, na mapě OpenCaching.com, který vznikl v roce 2010, bylo možné v polovině r. 2012 nalézt v Česku necelých 200 keší, zatímco na Geocaching.com jich již v roce 2008 bylo téměř 12000.

Historie a současnost 
Geocaching vznikl v USA bezprostředně poté, co 1. května 2000 rozhodnutí tehdejšího amerického prezidenta Clintona odstranilo umělou odchylku, přidávanou do signálu GPS, a zlepšilo tak přesnost tohoto navigačního systému pro běžné civilní uživatele z desítek až stovek na několik metrů.

K červnu 2005 bylo ve 215 zemích na celém světě přes 171 000 skrýší pro geocaching, z toho zhruba 700 v Česku. V září roku 2006 vzrostl počet skrýší v Česku na celkem 2570 a český geocaching dále prožíval svůj boom, neboť v listopadu 2007 bylo na českém území zaregistrováno již přes 5600 skrýší. Na začátku března 2008 bylo na světě registrováno přes půl milionu míst, z toho 6600 v Česku. Podle statistik serveru geocaching.com najde alespoň jednu cache za týden v průměru kolem 50 tisíc lidí. V ČR bylo založeno do 30. listopadu 2008 11496 keší, a do 31. srpna 2009 15707 keší V červenci 2012 dosáhl počet keší na celém světě čísla 1,5 milionu. V lednu 2014 dosahuje počet keší v systému Geocaching.com celosvětově 2,3 milionu, počet geocacherů přes 6 milionů. Počet aktivních keší v ČR je na počátku roku 2015 přes 40 tisíc, aktivních geocacherů kolem dvaceti tisíc.

Komunita geocacherů organizuje rozmanité kolektivní akce („setkávací“ cache) s programem jako jsou např. úklidy v přírodě, geosetkání, geohry (viz výše CITO cache, Event cache).

Geocaching se těší velké popularitě zejména ve střední a severní Evropě. Nejvíce nálezů na světě má geocache na Karlově mostě v Praze.

Kontroverze a problémy 
Cacheři při dohledávání geocache bývají konfrontováni policií, s dotazem, co provádí na místě keše. V jiných případech dohledávání geocache na místě uložení vyústilo v informování záchranných složek o podezřelé aktivitě. Došlo k tomu, že veřejné budovy či školy byly evakuovány, když učitelé či policejní jednotky objevili geocache, jako se stalo v případě střední školy Fairview High School v roce 2009. V několika případech byl obsah geocache zneškodněn pyrotechnickými jednotkami, protože existovalo podezření, že v krabičce je uschován nástražný výbušný systém. Rozličné oblasti, od starých hřbitovů po Disneyland, byly v důsledku nalezení geocache přechodně uzavřeny pro veřejnost.

Umístění geocachí bývá někdy terčem kritiky vládních orgánů či veřejnosti. Geocache bývají zaměněny s odpadem. Někteří geocacheři však při hledání geocache odpad z místa umístění naopak odnáší, tato praktika je úzce spojena s tzv. CITO eventy (Cache-In-Trash-Out). Eventy a geocache jsou často spojeny s ekologií a úklidem odpadu, mnoho oblastí tak vypadá čistěji, než bylo dříve a nejsou k tomu zapotřebí státní či lokální finanční zdroje. Geocaching není v USA protizákonný a obvykle je v případě, že je vysvětlen úředníkům, vnímán pozitivně. Nicméně, některá umístění geocache mohou být problematická. Ačkoliv je v pravidlech Groundspeaku zakázáno umisťovat geocache na soukromý majetek bez adekvátních povolení, tak se to stává a posléze je možné, že ostatní geocacheři mohou neoprávněně vniknout na cizí pozemek. Geocache také mohou být uschovány na místech, kde samotné dohledávání může vypadat podezřele (např. blízko škol, dětských hřišť, bank, soudů nebo v rezidentních oblastech). Podobný případ také může nastat, pokud je cache umístěna na místě, kde může být zaměněna za drogový balíček či bombu (speciálně v místech, kde se pohybuje mnoho lidí, pod mosty, poblíž bank, soudů či ambasád). I přes zmíněné problémy s odpadem či nástražnými výbušnými systémy, mohou někteří geocacheři umístit geocache na nebezpečná místa. Ukrytí geocache na těchto místech se nedoporučuje a webové stránky spojené s ukládáním geocachí se snaží vynutit dodržování pravidel a doporučují zakázat některé typy umístění. Nicméně, reviewři (uživatelé schvalující geocache) zpravidla nemohou přesně vidět kde a jak je každá jednotlivá geocache schovaná. Konečně, největší díl zodpovědnosti je na samotných geocacherech, mají možnosti reportovat problémy s umístěním geocache a také si musí počínat s nejvyšší opatrností.

Regionální pravidla pro ukládání geocachí mohou být poměrně komplexní. Například, ve Virginii Virginské Oddělení dopravy (Virginia Department of Transporation) a Agentura pro správu divoké přírody (Wildlife Management Agency) nedávno zakázali ukládání geocachí na všech územích pod kontrolou těchto organizací. Některá města a rekreační oblasti povolují ukládání geocachí s málo či žádnými omezeními, jiná však vyžadují komplikovaná povolení.

Rada Jižní Karolíny schválila v roce 2005 zákon č. 3777, ve kterém stojí: „Je zakázáno provozovat geocaching či letterboxing na hřbitově nebo na historickém či archeologickém nalezišti nebo na nemovitosti veřejně označené jako historická památka bez přímého písemného svolení správce hřbitova či pozemku.“ Zákon byl schválen při prvním čtení v Senátu a od té doby je platný.

Tři dospělí geocacheři, 24letá žena a její rodiče byli při hledání ammoboxu uvězněni v jeskyni a zachráněni hasiči v Rochesteru, ve státě New York. Mluvčí Rochesterských hasičů plk. Ted Kuppinger sdělil: „Je to komplikované, protože pokud se snažíte najít něco takového, tak se pravděpodobně pokusíte překonat sami sebe a přeceníte svoje síly.“

Úmrtí při geocachingu 
Při geocachingu zemřelo několik osob. Úmrtí jedenadvacetiletého zkušeného geocachera v prosinci 2011 s tématem „při přístupu ke keši to nevypadalo tak nebezpečně“ vedlo k diskuzi na fórech Groundspeaku o změnách, které by měly být provedeny a o tom, zda by Groundspeak či majitelé geocachí měli nést zodpovědnost.

V červnu 2018 smetla přívalová povodeň čtveřici geokačerů v zatrubněné části Motolského potoka v Praze. Dva lidé v přívalové povodni utonuli.

Nejaktivnější geokačeři v České republice a jinde

svět 
Ve statistice evidováno 521 103 geokačerů světa v následujícím pořadí nálezů: 1. mondou2 (USA, Colorado) 214 940 nálezů, 2. Alamogul (USA, Kalifornie) 209 264 nálezů, 3. racer2814 (USA, Illinois) 145 785 nálezů, 4. IMSpider (USA, Delawere) 143 143 nálezů, 5, anonymní, 6. MT-Jonea (Česká republika) 135 734 nálezů, 7. Dave w/o id (USA, New York) 135 655 nálezů atd. (k 5. 3. 2021)

Zastoupení států u prvních 20. míst: 14 x USA, 2 x anonymní, po jednom zástupci Česká republika, Španělsko, Kanada a Francie.

Česká republika 
V České republice evidováno 39 012 geokačerů k 5. 3. 2021. Nejúspěšnějšími geokačeři: 1. MT-Jonea (135 734 nálezů), 2. werg (99 094 nálezů) a 3. otasparta (98 679 nálezů).

 Austrálie: 8 973 geokačerů, 1. místo Liz a Bruce 64 427 nálezů
 Francie: 20 666 geokačerů, 1. místo vilcanota 101 565 nálezů
 Německo: 151 046 geokačerů, 1. a 2. místo je anonymní a 3. místo geoteddybear 76 028 nálezů 
 Rakousko: 10 862 geokačerů, 1. místo Skihasen 78 070 nálezů
 Spojené království: 30 000 geokačerů, 1. místo Simplysup 73 402 nálezů
 USA: 113 592 geokačerů, 1. místo mondou2 214 940 nálezů

Odkazy

Reference

Literatura

Související články 
 Letterboxing
 Wherigo
 Waymarking
 Degree Confluence Project
 ROT13
 GEOFUN

Externí odkazy 
 
 
 
 www.geocaching.com – Oficiální stránka 
 kesky.cz – Oficiální český průvodce Geocachingem
 wiki.geocaching.cz – česká encyklopedie geocachingu
 www.geocaching.cz – český diskusní server
 www.cageo.cz – Česká asociace geocachingu
 navigovat.mobilmania.cz – Garmin spouští OpenCaching: porazí Geocaching?

 
Pobyt v přírodě
GPS
Venkovní hry

Події 
 18 травня — відкрито рух поїздів дільницями »Ясинувата — Синельникове» і «Казанка — Катеринослав». Зданий в експлуатацію залізничний міст через Дніпро.

Народились 
Див. також :Категорія:Народились 1884
 24 березня — Петер Дебай, нідерландський фізико-фімик, лауреат Нобелівської премії.
 8 травня — Гаррі Трумен, 33-й президент США (1945—1953 рр)
 23 травня — Даглас Фербенкс, актор
 18 червня — Едуар Даладьє, французький державний і політичний діяч
 7 липня — Ліон Фойхтванґер, німецький письменник
 12 липня — Амедео Модільяні, італійський художник і скульптор
 23 липня — Еміль Янінгс, німецький актор
 2 серпня — Ромуло Гальєгос, венесуельський письменник, просвітитель, президент Венесуели
 27 серпня — Венсан Оріоль, президент Франції (1947—1954 рр.)

 Померли Див. також :Категорія:Померли 1884''
 26 січня — Чубинський Павло Платонович, український етнограф, фольклорист, поет
 24 листопада — Воробкевич Григорій Іванович, український поет

1880-ті

# The Lodash Threat Model

The Lodash threat model defines what Lodash trusts and does not trust when executing within a JavaScript environment. Lodash is a general-purpose utility library that operates within the same trust boundaries as the code that calls it. Therefore, vulnerabilities requiring the compromise of trusted elements — such as the JavaScript runtime, the host environment, or developer-controlled inputs — lie outside the scope of this threat model.

For a vulnerability to be considered within scope, it must result from Lodash itself violating its documented behavior or failing to maintain integrity, confidentiality, or availability under its standard usage assumptions.


## Elements Lodash Does NOT Trust

1. **Data provided to Lodash functions**  
Lodash treats all input data (arrays, objects, strings, functions, etc.) as untrusted. It does not attempt to validate or sanitize the semantic correctness of inputs — it operates on values as they are given.  
*If an untrusted input can cause Lodash to execute behavior beyond what is documented — such as prototype pollution, type confusion, memory exhaustion, or code injection — that would indicate a security vulnerability.*

2. **Untrusted network sources or user-controlled data**  
Any input derived from unvalidated user input, network responses, file contents, or deserialized data is untrusted. Lodash does not perform input isolation or sandboxing.

3. **Tampering with Lodash internals at runtime**  
Modifying Lodash’s internal symbols, monkey-patching its functions, or overwriting internal references at runtime is outside the trusted boundary.  
*If such modification changes Lodash behavior, that reflects a compromise of trusted code, not a Lodash vulnerability.*


## Elements Lodash Trusts

1. **The JavaScript runtime and its standard library**  
Lodash assumes a correct, uncompromised runtime environment (e.g., Node.js, browser). Vulnerabilities in the runtime (e.g., prototype chain issues, engine crashes) are out of scope.

2. **The environment and its configuration**  
Lodash relies on the correct functioning of the host environment (Node.js, browser, Deno, etc.) and any global objects or APIs it uses (e.g., `Object`, `Array`, `Function`, `JSON`).

3. **The code that invokes Lodash**  
The application or library using Lodash is responsible for validating user input, performing security checks, and handling execution context appropriately.

4. **Installed package integrity**  
Lodash assumes that the package installed (via npm, cdn, etc.) has not been tampered with and originates from the legitimate Lodash distribution channel.  
*Supply-chain compromise or malicious clones are not considered Lodash vulnerabilities.*

5. **The privileges and permissions of the execution context**  
Lodash inherits the privileges of the user or process that invokes it. Misuse or over-privileged execution environments (e.g., running as root, or with excessive browser permissions) are not within scope.

## Examples of Vulnerabilities (in scope)

- **Prototype Pollution ([CWE-1321](https://cwe.mitre.org/data/definitions/1321.html))**  
  If a Lodash function (e.g., `merge`, `defaultsDeep`, or `set`) allows modification of `Object.prototype` properties via untrusted input (e.g., `__proto__` keys) due to insufficient sanitization, it is in scope.  
  This class of vulnerability has been observed in prior Lodash versions (e.g., [CVE-2019-10744](https://www.cve.org/CVERecord?id=CVE-2019-10744)).

- **Unexpected code execution ([CWE-94](https://cwe.mitre.org/data/definitions/94.html))**  
  If a Lodash method (e.g., `template()`) executes attacker-controlled input as code without documented warnings or sanitization requirements, that is a Lodash vulnerability (e.g., [CVE-2021-23337](https://nvd.nist.gov/vuln/detail/CVE-2021-23337)).

- **Denial of Service (DoS) through logic flaws ([CWE-400](https://cwe.mitre.org/data/definitions/400.html))**  
  If Lodash enters unbounded recursion, excessive memory usage, or hangs when operating on otherwise valid inputs within documented usage limits, this is a vulnerability in Lodash (e.g, [CVE-2020-28500](https://www.cve.org/CVERecord?id=CVE-2020-28500)).

## Security notice: `_.template`

The current implementation of `_.template` compiles template strings into executable code, which can lead to code injection when given untrusted input (e.g., [CVE-2021-23337](https://nvd.nist.gov/vuln/detail/CVE-2021-23337)). For that reason we consider it insecure and advise against its use.

We plan to remove `_.template` in Lodash v5. Until then it remains available; if you continue to use it, we recommend using only developer-controlled, static template strings and trusted data, and avoiding untrusted input (e.g. user-controlled data or unvalidated network content) in both the template string and the data passed to the compiled function.

## Examples of Non-Vulnerabilities (out of scope)

### Malicious Third-Party Packages ([CWE-1357](https://cwe.mitre.org/data/definitions/1357.html))

If a project includes a malicious dependency that overrides Lodash behavior or injects malicious code into Lodash’s namespace, it does not represent a Lodash vulnerability. Lodash trusts its runtime and installation context.

### Unvalidated Application Input

Applications using Lodash are responsible for input validation. Passing attacker-controlled data directly into Lodash functions (e.g., `_.merge(req.body, config)`) is an application bug, not a Lodash vulnerability.

### Prototype Pollution via Trusted Code

If a developer intentionally merges user input into global objects or fails to isolate data structures, that is a misuse of Lodash’s documented API, not a Lodash defect.

### Stateful or Accessor-Backed Path Arguments

Path arguments to Lodash functions are expected (and documented) to be data, not code. Functions like `_.get`, `_.set`, `_.pick`, `_.unset`, and `_.omit` take paths as strings or arrays of strings and numbers.

Getters, setters, and Proxies are code, not data. They run JavaScript code when a property is read, and they can't be serialized as JSON or sent over the wire. Something has to call `Object.defineProperty` (or equivalent) from inside the process to set them up.

If a report relies on a path element returning different values on different reads (a check/use mismatch), the attack needs code running inside the process, not just attacker-supplied data. That puts it outside Lodash's trust boundary; see "code that invokes Lodash" under [Elements Lodash Trusts](#elements-lodash-trusts).

### Inherent JavaScript Prototype Behavior

Lodash blocks writes to built-in prototypes. Keys like `__proto__` and `constructor.prototype` are filtered in `_.set`, `_.merge`, and similar functions. It does not and cannot block reads.

Reading inherited properties is how JavaScript works. `obj.constructor`, traversing `__proto__`, or reaching `Object.prototype` through normal property resolution are language semantics, not Lodash behavior.

If a report shows only read-only prototype access (e.g. `_.get(obj, 'constructor.prototype')` returning `Object.prototype`), it's describing JavaScript, not a Lodash vulnerability.

### Vulnerability Chaining and Gadgets

A Lodash vulnerability has to be exploitable through Lodash alone. If a report's impact depends on combining Lodash behavior with a separate bug in another library or application component, the bug is in the downstream code, not Lodash.

Gadget reports fall under this too. If a Lodash function produces an object shape that later causes a vulnerable function in some other library to execute code, the root cause is that library accepting the shape, not Lodash producing it.

### Vulnerabilities in the JavaScript Runtime or Platform

If a Lodash method triggers a bug in the JavaScript engine (e.g., V8, SpiderMonkey, JavaScriptCore) that leads to memory corruption or incorrect behavior, the vulnerability lies in the engine, not Lodash.

### Environmental Misconfiguration ([CWE-15](https://cwe.mitre.org/data/definitions/15.html))

Issues arising from misconfigured execution environments, such as running outdated Node.js versions or insecure Content Security Policies in browsers, are not considered Lodash vulnerabilities.

### Supply Chain Compromise

Tampering with Lodash packages in the npm registry, MITM attacks during installation, or local file system manipulation are not vulnerabilities in Lodash itself.


## Summary

Lodash is a utility library operating entirely within the trust boundary of its caller. Vulnerabilities in scope are limited to cases where **Lodash fails to uphold its documented behavior** in the presence of **untrusted input**, without assuming compromise of trusted components such as the runtime, the operating system, or the invoking application code.

#![cfg(feature = "kv")]
#![feature(test)]

use log::kv::Value;

#[bench]
fn u8_to_value(b: &mut test::Bencher) {
    b.iter(|| Value::from(1u8));
}

#[bench]
fn u8_to_value_debug(b: &mut test::Bencher) {
    b.iter(|| Value::from_debug(&1u8));
}

#[bench]
fn str_to_value_debug(b: &mut test::Bencher) {
    b.iter(|| Value::from_debug(&"a string"));
}

#[bench]
fn custom_to_value_debug(b: &mut test::Bencher) {
    #[derive(Debug)]
    struct A;

    b.iter(|| Value::from_debug(&A));
}

Asatro är en modern beteckning på de religiösa traditioner och seder som utövades av invånarna i Skandinavien från folkvandringstiden och under vikingatiden fram till religionsskiftet. Kunskapen om asatron bygger huvudsakligen på nedteckningar från kristen medeltid, men som förutsätts spegla en äldre muntlig tradition. Svenska akademiens ordbok definierar asatro som ”en nordisk naturreligion där polyteism och naturväsen är centrala inslag utbredd i nord-germanska länder innan kristendomens införande”.

Begreppet asatro 
Begreppet asatro myntades under 1800-talet, då den nationalromantiska, samnordiska synen på vikingatiden skapades, och ett stort intresse för förkristen mytologi väcktes också i Tyskland (med Richard Wagners operasvit som främsta exempel). SAOB:s första belägg för begreppet är från 1820. 
Under medeltiden användes benämningen fornsed (medeltida stavning: forn siðr eller fornum sid) –  – för att beskriva tron och sederna innan kristendomen.

Som synonym för asatro används ofta fornnordisk religion, men detta begrepp omfattar även andra förkristna nordiska religioner, såsom samisk religion, finsk religion och Nerthuskult. En del svenska akademiker har därför börjat använda begreppet fornskandinavisk religion som synonym till asatro för att avgränsa mot just samisk och finsk religion. Asatro avser religionen som fanns i perioden precis innan kristendomens införande, medan de förkristna religiösa uttrycken som fanns under bronsålder och stenålder i Norden skiljde sig från asatron.

Skriftliga och arkeologiska källor 

Det som är känt om asatrons trosuppfattningar kommer främst från kristna källor, antingen isländska sagor nedtecknade efter kristnandet genomförts på Island, eller från kristna grannar som verkat samtidigt som asatron varit levande i Skandinavien, till exempel Adam av Bremen. Även Cornelius Tacitus skrev om germanerna och deras trosuppfattningar. De viktigaste källorna till nordisk mytologi är den poetiska Eddan och Snorres Edda från 1200-talet.

Det finns även arkeologiska källor som ger oss ledtrådar till hur och var asatron utövas. Ortnamn ger ofta vägledning om vilka gudar och gudinnor som dyrkades på en viss plats och sambandet mellan dessa. I nordiska ortnamn ingår följande gudars namn: Tor, Njord, Ull, Frö, Oden, Ti (Tyr), Frigg, Fröja, med binamnet Härn (isländska "Hörn"), Vrind (isländska Rind), möjligen också Vidar, Balder, Höder och Skade. Av gudomlighetsnamn används gud, as, dis, troligen också van, medan det i personnamnen ingår Tor, Frö, Oden, möjligen också Ti, liksom gud, as, ragn (gudamakt), dis, alv samt benämningar på valkyrior. Guden Ull har efterlämnat spår i ett stort antal svenska ortnamn som Ulleråker och Ullevi. Så trots att Ull har en undanträngd roll i Eddorna, så tycks han haft en viktig roll i de lokala offerkulterna.

Bakgrund 
Asatron utgjorde aldrig ett sammanhängande religiöst system, varför man kan säga att Snorre Sturlasson med sin Edda var den som först sammanförde berättelserna till en helhet. Den förkristna nordiska asatron var alltså aldrig någon enhetlig religion i modern bemärkelse utan var snarare en etnisk religion eller naturreligion, som saknade grundare och fastställda lärosatser. Mytologin fungerade troligen som en sorts teoretisk överbyggnad till kulten, som hade mycket lite att göra med tro och mer med handlande, traditioner och värderingar i samband med naturen, vädret, årstiderna och mänsklig verksamhet.

Asatro tillhör de polyteistiska religionerna, och förutom gudar tror man även på olika naturväsen. Asatron är en del av en större familj av indoeuropeiska religioner där man även finner grekisk, romersk och slavisk fornreligion. Det finns även motsvarigheter till asatrons panteon i den indiska hinduismen. En teori hävdar att olika indoeuropeiska stammar (indier, greker, italiker, kelter, slaver, germaner) har ett gemensamt ursprung, möjligen från områden i närheten av Svarta Havet och att dessa sedan utvandrat till övriga Europa samt Asien. Detta är en förklaring till likheten i religion och språk mellan dessa olika länder. Se urindoeuropéer.

Religionshistorikern Georges Dumézil menade att det urindoeuropeiska samhället varit uppdelat i tre delar, liknande det indiska kastsystemet. Detta kallade han trefunktionalitetssystemet. Detta tretal menade han även gestaltade sig i de indoeuropeiska gudsuppfattningen; de indoeuropeiska religionerna, menade han, hade alltid tre gudar som motsvarade den romerska mytologins Jupiter (övergud), Mars (krigsgud) och Quirinus (samhällsbeskyddaren och jordbruksgud). Han utvecklade sedan resonemanget med att uppställa ett schema över tretalens respektive egenskaper:
Den första stod för suveränitet, intelligens och helighet, och fungerade fredsbevarande.
Det andra för kraft och styrka, särskilt avseende krig, och fungerade som rättvisans princip.
Det tredje för tillgivenhet, samhällets bevarande, odling och jordbruk.
I ”De nordiska gudarna: en undersökning av den skandinaviska religionen” (1939) överförde han tretalssystemet till Eddan, och menade att det motsvarade Oden, Tor och Frej i den nordiska mytologin där Frej motsvarade jordbruket, Oden överguden och Tor var en krigsgud.

Under folkvandringstiden, efter Roms fall, vällde de germanska folken in över den europeiska kontinenten. De hade inte undgått påverkan från medelhavskulturerna men sin gamla tro tog de med sig och med dem spred den sig över Europa. Omkring år 500–750 ersattes denna tro gradvis av kristendomen i anglosaxarnas England och merovingernas Frankrike, och liksom senare i Skandinavien verkade de båda trossystemen parallellt med varandra under den tiden. Under denna period, alltså strax innan vikingatiden inletts, hade asatron sin största utbredning: Samma eller likartade gudar dyrkades över hela norra och västra Europa.
Dock försökte aldrig anhängarna till asatron att omvända de kristna och det var dömt att bli en tidsfråga innan de konverterade till kristendomen. I Norden dröjde kristnandet dock omkring 500 år längre än på kontinenten: Först kristnades Norge (900–1000), sedan Island (år 1000, enligt sagorna genom ett alltingsbeslut), Danmark, och sist Sverige av alla germanska områden; även om kristnandet framskred i olika takt i olika delar av länderna. Att nordborna blev kristna tolkas som ett tecken på deras integrering i det europeiska värdesystemet: även om den personliga övertygelsen lät vänta på sig underlättade det handeln att låta döpa sig.

Under seklerna som följde kristnandet, innan den kristna undervisningen hunnit etablera den kristna andan, levde dessutom skaldekonsten fortfarande vid hoven. Skalder kunde använda kenningar, hänsyftningar till den nordiska mytologin, och veta att han blev omedelbart förstådd; "dvärgarnas skepp" var skaldekonsten; "Fröjas tårar" var guldet; "valkyriornas eld" svärdet, "korpens öl" blodet, etc.

Asatron har karaktär av ursprunglig nordeuropeisk religion som dominerade större delen av Nordeuropa, alltså Skandinavien, England, Tyskland, Nederländerna och Belgien, bland andra. Det mesta vi vet om denna tro härstammar dock från Norden och i synnerhet Island. Det är inte säkert att övriga germanska folk omfattade exakt samma trosföreställningar som de forntida nordborna. Troligen varierade asatrons sedvänjor och myter avsevärt mellan de olika germanska folken och över tid. Att de religiösa föreställningarna i hela Skandinavien dock varit väsentligen desamma finns det dock mycket som tyder på. Skandinavien kristnades dessutom bortåt 500 år senare än exempelvis Tyskland och England. Mest hårdnackade i den gamla tron var folken i Sverige, som höll fast vid den "forna seden" ända in på 1100-talet, och det finns till och med vittnesmål om att människor åkallade asarna så sent som på 1500-talet i Småland.

Kosmologi 

I eddadikten Valans spådom, Völuspá, återges, via en völva (spåkvinna), myter om skapelsen, konflikterna i världen och världsundergången. Forskningen har diskuterat om Snorres text ger uttryck för en cyklisk världshistoria eller om den med ett definitivt världsslut är påverkad av kristendomen. Völvan berättar om den ursprungliga tomheten, Ginnungagap, om universums tillkomst (kosmogoni) och skapelsen av Ask och Embla, de första människorna (antropogoni), samt om striderna mellan gudar och jättar som leder fram till undergången, Ragnarök. Snorres Edda beskriver att världen uppstod i Ginnungagap, ett svalg där hetta och frost smälte samman till jätten Ymer och kon Audhumbla. Audhumbla slickade sedan fram mannen Bure ur isen. Bures sonsöner Oden, Vile och Ve dräpte därefter Ymer och skapade världen av hans kropp.

Den övergripande mytologiska berättelsen handlar om en kosmisk maktkamp mellan gudarna och kaoskrafter. Gudarna representerade den ordnade världen, kulturen och civilisationen, som ständigt hotades av naturens krafter, representerade av jättarna och kaosmonster (till exempel Fenrisulven och Midgårdsormen). Men minst lika viktigt är Asgårds beroende av den hemliga kunskap som jättar och andra demoniska väsen besitter och de allianser, och äktenskap, som knyts mellan dessa två världar.

Snorre ger i sin Edda detaljerade upplysningar om hur universums är beskaffat: Midgård kallas människornas värld, i Asgård lever gudarna. Utgård kallas den utanförvärld där de demoniska väsendena håller till och där Jotunheim finns. Runt jorden ringlar sig Midgårdsormen, och utanför detta vidunder finns det personifierade världshavet, Ägir. I världens mitt står trädet Yggdrasil. Det symboliserar strukturen i kosmos med sina rötter i Hels underjord och grenar som sträcker sig långt upp till gudarna. Vid trädets fot ligger jätten Mimers brunn, vars vatten förmedlar kunskap om det som varit och det som komma skall. De tre nornorna Urd (det förflutna), Verdandi (det nuvarande) och Skuld (det som komma skall) och spinner ödestrådarna. Hel är namnet både på det underjordiska dödsriket och på dess härskarinna. De som fallit i strid hämtas av valkyrior och kommer till Odens Valhall eller till Freja Folkvang. I det sista slaget, Ragnarök, kommer de härskande gudarna att falla och världen kommer att gå under i en eld, varefter en ny och bättre värld kommer att uppstå ur den gamla.

Kultplatser 

Kulten under järnåldern verkar mestadels ha utövats i hemmen, men skriftliga källor, bland annat Adam av Bremen, nämner att det skall ha funnits tempelbyggnader i Norden under vikingatiden, i alla fall i Uppsala. Vid utgrävningar i Uppåkra strax söder om Lund har man funnit rester efter ett tempel som stått här i flera hundra år före nedläggningen i slutet av 900-talet. Då hela byggnadens yta kunnat grävas fram och då platsen är oskadad från senare nedgrävningar har för första gången ett fornnordiskt tempel kunnat studeras i sin helhet rent arkeologiskt.
Mycket vanligare var de så kallade "vina", heliga platser utomhus. Detta återspeglas bland annat i många av de ortnamn som innehåller efterledet -vi, som till exempel Ullevi. 2007 undersöktes ett vi från vendeltid i Lilla Ullevi fullständigt. Viet i Lilla Ullevi bestod av olika lämningar, naturliga såväl som människoskapade; centralt fanns den så kallade hargen, en stenkonstruktion som ligger på viets högsta punkt. I hargen låg en plattform som antagligen fungerat som altare. Plattformen har efterlämnat spår i form av fyra kraftiga stolphål. Söder om stenkonstruktionen fanns ett stort antal stolphål, och arkeologerna antar att det kan ha varit en offerplats på grund av de många fynd av amulettringar som man gjort där. Ringar förekom även i hargen, där man funnit närmare 70 stycken järnringar, många med mindre ringar hängande i den största ringen. Ringar antas också ha betytt mycket i den nordiska kulten då de fungerat som dörringar på kultbyggnader, vilket man sett i templet i Uppåkra, och som också är avbildat på Sparlösastenen. Det isländska sagomaterialet bekräftar också ringarnas betydelse i kulten.

Blot 

Blot är ett offer i nordisk religion som syftar till att vinna gudars eller alvers välvilja så att de uppfyller dess önskemål, som genomför blotet. Ordet är släkt med gotiskans blôtan i meningen "dyrka, tillbedja", och forntyskans bluozan, i betydelsen "offra" och "stärka". Troligen har ordet ursprungsbetydelsen "åkalla med besvärjelse eller offer". Religionsprofessor Britt-Mari Näsström härleder ordet till en indoeuropeisk rot *bhle som betyder ”svälla, vara svullen” och i överförd bemärkelse ”tillta, öka”. Det betyder att offret i sig ökar den offrandes egendom.  
Offerritualerna verkar ha skett på två sätt; antingen frambar man offret till gudarna eller så tog man del av offergåvan genom att förtära den offrade maten och drycken. Det finns flera berättelser från norra Europa om stora offerfester med mat och dryck.

De isländska sagorna talar om tre årliga blot: höstblot, midvinterblot och vårblot.

Namngivna blothögtider 
 Disablot (början av februari)
 Segerblot (vårdagjämningen)
 Midsommarblot (midsommar)
 Skördeblot (augusti–september)
 Höstblot (mitten av oktober)
 Alvablot (november/allhelgona)
 Midvinterblot (januari)

Asatron efter kristnandet 

Sedan Nordeuropa kristnats och asatron förbjudits, allra sist i Sverige, levde en del av dess trosuppfattningar vidare i folktro och i folksagor, "Prins Hatt under jorden" är till exempel ursprungligen berättelser om guden Höder. En dikt från Trollkyrka i Tiveden redogör även för hur ett hemligt offer utfördes.
Men det finns också indikationer att asatron levde kvar länge i hemlighet; under digerdödens härjningar på 1300-talet berättas det att flera områden återgick till hedendomen i försök att hejda pestens härjningar, och det finns kätterimål från 1500-talet mot svenskar som dyrkat Oden. Myten om Odens jakt, liksom föreställningar om Tor, Fröja (Freja), Locke (Loke), Frigg och så vidare visar att allmogen långt fram på 1800- och början av 1900-talet hade kunskaper om den forna religionen. Man har också visat att så kallade älvkvarnar använts för offer långt in på 1800-talet.

Andra sedvänjor som kan tolkas som rester av asatro, är till exempel riten rörande Kornguden i Vånga, som var en helgonbild i Norra Vånga i Västergötland. Helgonbilden togs ut till åkrarna för att säkerställa att skörden blev god. 1826 försökte stiftet förhindra denna sed genom att undanskaffa helgonbilden men enligt Västgöta-Bengtsson så ska Vångaborna ha gjort sig en ny Korngud. Det är dock inget ovanligt att kristen helgondyrkan tett sig på detta vis, och flera exempel finns från kontinenten varför det inte med självklarhet går att göra kopplingen till asatron.
Ebbe Schön skriver i sin bok Asa-Tors hammare om hur rester av asatron levde kvar i folksagor ännu i början av 1900-talet.

Även om de högre gudarna i asatron så småningom försvann, så levde dess mindre väsen vidare i folktrons föreställningar om älvor, vättar, och tomtar och i tron på skogsrået, näcken, havsfrun med flera in i våra dagar och gör så alltjämt på sina ställen. När bonden satte ut en skål gröt till tomten på julnatten för att denne skulle se till djuren på gården, så utförde han en rit med urgamla anor, det som på vikingatid och tidig medeltid kallades blot.

Folktrons föreställningar om avlidnas själar och naturföreteelsernas andar återfinns i liknande skepnad hos många folk, och att de hos nordbor och övriga germaner varit väsentligen de samma intygas dels av överensstämmande folktro från yngre tid, dels av de gemensamma benämningarna för älva, mara, huldra, dvärg och näck. Om de germanska folkens gudatro finns några underrättelser ända från vår tideräknings början, och ett för dessa gemensamt drag är att utom träd, floder och berg vanligen tre, ibland fyra gudar uppges ha dyrkats: Caesar anger solen, Vulcanus (elden) och månen, Tacitus anger Mercurius, Hercules och Mars. I det saxiska doplöftet från 800-talet avsvärjs "Thuner och Woden och Saxnot och alla de onda makter, som är i deras sällskap".

Modern asatro 

I slutet av 1800-talet blommade återigen ett intresse för asatron upp. En andra våg kom på 1920-talet, och en tredje kom i samband med det ökande intresset för naturreligioner under 1960-talet. I dag finns det flera organisationer som sprider kunskap om mytologin, religionen och religiösa sammankomster, huvudsakligen i Skandinavien, England och USA. Det isländska ordet ásatrú har blivit det vanligaste ordet internationellt men även Odinism (efter det isländska/fornnordiska namnet på Oden) förekommer. Nordiska Asasamfundet (NAS), det största samfundet för Asatro i Sverige använder beteckningen asatro för religionen. I Skandinavien används ibland även beteckningen forn sed för denna religion av Samfundet Forn Sed Sverige.

Forskningshistoria kring asatro 
Friedrich Max Müller (1823–1900) var en tysk språkforskare som var intresserad av möjliga förbindelse mellan språk, religion och mytologi. Müller menade att naturfenomen blev till gudar genom en missuppfattning av naturlagarna. Müllers resonemang kan spåras i flera verk från 1800-talets slut, där de nordiska gudarna kom att förklaras som naturfenomen. Inom mytforskning kallas detta för den naturmytologiska skolan. Från 1800-talets slut fick den naturmytologiska skolan kritik. Norske Sophus Bugge (1833–1907) och tyske Eugen Mogk kom att representera en ny källkritisk riktning i forskningen och menade att de nordiska myterna först och främst var en produkt Nordens möte med kristendomen. I Bugges huvudverk, De nordiske Gude- og Heltesagns Oprindelse, menade han att den nordiska mytologin hade skapats i möte med kristendomens texter och litterära traditioner. Han menade vidare att asatron hade inspirerats av keltiska och anglosaxiska traditioner med lån från grekisk och romersk mytologi. På 2000-talet har Bugges teori ingen stark ställning. Gro Steinsland menar dock att Bugges forskning "banade väg för den källkritiska debatten som uppstod och som fortfarande förs". Bugges kommenterade utgåva av Den eldre Edda (1867) betraktas fortfarande som ett standardverk för de som arbetar källkritiskt med eddadikterna.

Källtexter 
Följande texter och föremål utgör historiska källor till kunskap om den nordiska mytologins innehåll, som de i olika utsträckning nämner och behandlar:

 Tacitus: Germania (ca 98 e.kr.)
 Snorre Sturlason:
 Codex Regius (”Kungliga boken”) eller Poetiska Eddan (ca 800 e.kr.)
 Prosaiska Eddan  (ca 1200 e.kr.)
 Saxo Grammaticus: Gesta Danorum (ca 1200 e.kr.)
 Runstenar
 Beowulfskvädet
 Tjodolf av Hvin:
 Ynglingasagan
 Haustlong
 Eilif Gudrunarson: Thórsdrápa
 Adam av Bremen: Gesta Hammaburgensis ecclesiae pontificum

Referenser

<a id="top"></a>
# Test fixtures

**Contents**<br>
[Non-Templated test fixtures](#non-templated-test-fixtures)<br>
[Templated test fixtures](#templated-test-fixtures)<br>
[Signature-based parameterised test fixtures](#signature-based-parameterised-test-fixtures)<br>
[Template fixtures with types specified in template type lists](#template-fixtures-with-types-specified-in-template-type-lists)<br>

## Non-Templated test fixtures

Although Catch2 allows you to group tests together as 
[sections within a test case](test-cases-and-sections.md), it can still 
be convenient, sometimes, to group them using a more traditional test. 
Catch2 fully supports this too with 3 different macros for 
non-templated test fixtures. They are: 

| Macro    | Description |
|----------|-------------|
|1. `TEST_CASE_METHOD(className, ...)`| Creates a uniquely named class which inherits from the class specified by `className`. The test function will be a member of this derived class. An instance of the derived class will be created for every partial run of the test case. |
|2. `METHOD_AS_TEST_CASE(member-function, ...)`| Uses `member-function` as the test function. An instance of the class will be created for each partial run of the test case. |
|3. `TEST_CASE_PERSISTENT_FIXTURE(className, ...)`| Creates a uniquely named class which inherits from the class specified by `className`. The test function will be a member of this derived class. An instance of the derived class will be created at the start of the test run. That instance will be destroyed once the entire test case has ended. |

### 1. `TEST_CASE_METHOD`


You define a `TEST_CASE_METHOD` test fixture as a simple structure:

```c++
class UniqueTestsFixture {
  private:
   static int uniqueID;
  protected:
   DBConnection conn;
  public:
   UniqueTestsFixture() : conn(DBConnection::createConnection("myDB")) {
   }
  protected:
   int getID() {
     return ++uniqueID;
   }
 };

 int UniqueTestsFixture::uniqueID = 0;

 TEST_CASE_METHOD(UniqueTestsFixture, "Create Employee/No Name", "[create]") {
   REQUIRE_THROWS(conn.executeSQL("INSERT INTO employee (id, name) VALUES (?, ?)", getID(), ""));
 }
 TEST_CASE_METHOD(UniqueTestsFixture, "Create Employee/Normal", "[create]") {
   REQUIRE(conn.executeSQL("INSERT INTO employee (id, name) VALUES (?, ?)", getID(), "Joe Bloggs"));
 }
```

The two test cases here will create uniquely-named derived classes of 
UniqueTestsFixture and thus can access the `getID()` protected method 
and `conn` member variables. This ensures that both the test cases 
are able to create a DBConnection using the same method 
(DRY principle) and that any ID's created are unique such that the 
order that tests are executed does not matter. 

### 2. `METHOD_AS_TEST_CASE`

`METHOD_AS_TEST_CASE` lets you register a member function of a class 
as a Catch2 test case. The class will be separately instantiated 
for each method registered in this way.

```cpp
class TestClass {
    std::string s;

public:
    TestClass()
        :s( "hello" )
    {}

    void testCase() {
        REQUIRE( s == "hello" );
    }
};


METHOD_AS_TEST_CASE( TestClass::testCase, "Use class's method as a test case", "[class]" )
```

This type of fixture is similar to [TEST_CASE_METHOD](#1-test_case_method) except in this 
case it will directly use the provided class to create an object rather than a derived 
class.

### 3. `TEST_CASE_PERSISTENT_FIXTURE`

> [Introduced](https://github.com/catchorg/Catch2/pull/2885) in Catch2 3.7.0

`TEST_CASE_PERSISTENT_FIXTURE` behaves in the same way as
[TEST_CASE_METHOD](#1-test_case_method) except that there will only be
one instance created throughout the entire run of a test case. To 
demonstrate this have a look at the following example:

```cpp
class ClassWithExpensiveSetup {
public:
    ClassWithExpensiveSetup() {
        // expensive construction
        std::this_thread::sleep_for( std::chrono::seconds( 2 ) );
    }

    ~ClassWithExpensiveSetup() noexcept {
        // expensive destruction
        std::this_thread::sleep_for( std::chrono::seconds( 1 ) );
    }

    int getInt() const { return 42; }
};

struct MyFixture {
    mutable int myInt = 0;
    ClassWithExpensiveSetup expensive;
};

TEST_CASE_PERSISTENT_FIXTURE( MyFixture, "Tests with MyFixture" ) {

    const int val = myInt++;

    SECTION( "First partial run" ) {
        const auto otherValue = expensive.getInt();
        REQUIRE( val == 0 );
        REQUIRE( otherValue == 42 );
    }

    SECTION( "Second partial run" ) { REQUIRE( val == 1 ); }
}
```

This example demonstrates two possible use-cases of this fixture type:
1. Improve test run times by reducing the amount of expensive and 
redundant setup and tear-down required.
2. Reusing results from the previous partial run, in the current
partial run.

This test case will be executed twice as there are two leaf sections.
On the first run `val` will be `0` and on the second run `val` will be 
`1`. This demonstrates that we were able to use the results of the
previous partial run in subsequent partial runs.

Additionally, we are simulating an expensive object using 
`std::this_thread::sleep_for`, but real world use-cases could be:
1. Creating a D3D12/Vulkan device
2. Connecting to a database
3. Loading a file.

The fixture object (`MyFixture`) will be constructed just before the
test case begins, and it will be destroyed just after the test case 
ends. Therefore, this expensive object will only be created and 
destroyed once during the execution of this test case. If we had used 
`TEST_CASE_METHOD`, `MyFixture` would have been created and destroyed 
twice during the execution of this test case.

NOTE: The member function which runs the test case is `const`. Therefore 
if you want to mutate any member of the fixture it must be marked as
`mutable` as shown in this example. This is to make it clear that
the initial state of the fixture is intended to mutate during the
execution of the test case.

## Templated test fixtures

Catch2 also provides `TEMPLATE_TEST_CASE_METHOD` and
`TEMPLATE_PRODUCT_TEST_CASE_METHOD` that can be used together
with templated fixtures and templated template fixtures to perform
tests for multiple different types. Unlike `TEST_CASE_METHOD`,
`TEMPLATE_TEST_CASE_METHOD` and `TEMPLATE_PRODUCT_TEST_CASE_METHOD` do
require the tag specification to be non-empty, as it is followed by
further macro arguments.

Also note that, because of limitations of the C++ preprocessor, if you
want to specify a type with multiple template parameters, you need to
enclose it in parentheses, e.g. `std::map<int, std::string>` needs to be
passed as `(std::map<int, std::string>)`.
In the case of `TEMPLATE_PRODUCT_TEST_CASE_METHOD`, if a member of the
type list should consist of more than single type, it needs to be enclosed
in another pair of parentheses, e.g. `(std::map, std::pair)` and
`((int, float), (char, double))`.

Example:
```cpp
template< typename T >
struct Template_Fixture {
    Template_Fixture(): m_a(1) {}

    T m_a;
};

TEMPLATE_TEST_CASE_METHOD(Template_Fixture,
                          "A TEMPLATE_TEST_CASE_METHOD based test run that succeeds",
                          "[class][template]",
                          int, float, double) {
    REQUIRE( Template_Fixture<TestType>::m_a == 1 );
}

template<typename T>
struct Template_Template_Fixture {
    Template_Template_Fixture() {}

    T m_a;
};

template<typename T>
struct Foo_class {
    size_t size() {
        return 0;
    }
};

TEMPLATE_PRODUCT_TEST_CASE_METHOD(Template_Template_Fixture,
                                  "A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test succeeds",
                                  "[class][template]",
                                  (Foo_class, std::vector),
                                  int) {
    REQUIRE( Template_Template_Fixture<TestType>::m_a.size() == 0 );
}
```

_While there is an upper limit on the number of types you can specify
in single `TEMPLATE_TEST_CASE_METHOD` or `TEMPLATE_PRODUCT_TEST_CASE_METHOD`,
the limit is very high and should not be encountered in practice._

## Signature-based parameterised test fixtures

> [Introduced](https://github.com/catchorg/Catch2/issues/1609) in Catch2 2.8.0.

Catch2 also provides `TEMPLATE_TEST_CASE_METHOD_SIG` and `TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG` to support
fixtures using non-type template parameters. These test cases work similar to `TEMPLATE_TEST_CASE_METHOD` and `TEMPLATE_PRODUCT_TEST_CASE_METHOD`,
with additional positional argument for [signature](test-cases-and-sections.md#signature-based-parametrised-test-cases).

Example:
```cpp
template <int V>
struct Nttp_Fixture{
    int value = V;
};

TEMPLATE_TEST_CASE_METHOD_SIG(
    Nttp_Fixture,
    "A TEMPLATE_TEST_CASE_METHOD_SIG based test run that succeeds",
    "[class][template][nttp]",
    ((int V), V),
    1, 3, 6) {
    REQUIRE(Nttp_Fixture<V>::value > 0);
}

template<typename T>
struct Template_Fixture_2 {
    Template_Fixture_2() {}

    T m_a;
};

template< typename T, size_t V>
struct Template_Foo_2 {
    size_t size() { return V; }
};

TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG(
    Template_Fixture_2,
    "A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that succeeds",
    "[class][template][product][nttp]",
    ((typename T, size_t S), T, S),
    (std::array, Template_Foo_2),
    ((int,2), (float,6))) {
    REQUIRE(Template_Fixture_2<TestType>{}.m_a.size() >= 2);
}
```

## Template fixtures with types specified in template type lists

Catch2 also provides `TEMPLATE_LIST_TEST_CASE_METHOD` to support template fixtures with types specified in
template type lists like `std::tuple`, `boost::mpl::list` or `boost::mp11::mp_list`. This test case works the same as `TEMPLATE_TEST_CASE_METHOD`,
only difference is the source of types. This allows you to reuse the template type list in multiple test cases.

Example:
```cpp
using MyTypes = std::tuple<int, char, double>;
TEMPLATE_LIST_TEST_CASE_METHOD(Template_Fixture,
                               "Template test case method with test types specified inside std::tuple",
                               "[class][template][list]",
                               MyTypes) {
    REQUIRE( Template_Fixture<TestType>::m_a == 1 );
}
```

---

[Home](Readme.md#top)

// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
// file at the top-level directory of this distribution and at
// http://rust-lang.org/COPYRIGHT.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.

//! A lightweight logging facade.
//!
//! The `log` crate provides a single logging API that abstracts over the
//! actual logging implementation. Libraries can use the logging API provided
//! by this crate, and the consumer of those libraries can choose the logging
//! implementation that is most suitable for its use case.
//!
//! If no logging implementation is selected, the facade falls back to a "noop"
//! implementation that ignores all log messages. The overhead in this case
//! is very small - just an integer load, comparison and jump.
//!
//! A log request consists of a _target_, a _level_, and a _body_. A target is a
//! string which defaults to the module path of the location of the log request,
//! though that default may be overridden. Logger implementations typically use
//! the target to filter requests based on some user configuration.
//!
//! # Usage
//!
//! The basic use of the log crate is through the five logging macros: [`error!`],
//! [`warn!`], [`info!`], [`debug!`] and [`trace!`]
//! where `error!` represents the highest-priority log messages
//! and `trace!` the lowest. The log messages are filtered by configuring
//! the log level to exclude messages with a lower priority.
//! Each of these macros accept format strings similarly to [`println!`].
//!
//!
//! [`error!`]: ./macro.error.html
//! [`warn!`]: ./macro.warn.html
//! [`info!`]: ./macro.info.html
//! [`debug!`]: ./macro.debug.html
//! [`trace!`]: ./macro.trace.html
//! [`println!`]: https://doc.rust-lang.org/stable/std/macro.println.html
//!
//! Avoid writing expressions with side-effects in log statements. They may not be evaluated.
//!
//! ## In libraries
//!
//! Libraries should link only to the `log` crate, and use the provided
//! macros to log whatever information will be useful to downstream consumers.
//!
//! ### Examples
//!
//! ```
//! # #[derive(Debug)] pub struct Yak(String);
//! # impl Yak { fn shave(&mut self, _: u32) {} }
//! # fn find_a_razor() -> Result<u32, u32> { Ok(1) }
//! use log::{info, warn};
//!
//! pub fn shave_the_yak(yak: &mut Yak) {
//!     info!(target: "yak_events", "Commencing yak shaving for {yak:?}");
//!
//!     loop {
//!         match find_a_razor() {
//!             Ok(razor) => {
//!                 info!("Razor located: {razor}");
//!                 yak.shave(razor);
//!                 break;
//!             }
//!             Err(err) => {
//!                 warn!("Unable to locate a razor: {err}, retrying");
//!             }
//!         }
//!     }
//! }
//! # fn main() {}
//! ```
//!
//! ## In executables
//!
//! Executables should choose a logging implementation and initialize it early in the
//! runtime of the program. Logging implementations will typically include a
//! function to do this. Any log messages generated before
//! the implementation is initialized will be ignored.
//!
//! The executable itself may use the `log` crate to log as well.
//!
//! ### Warning
//!
//! The logging system may only be initialized once.
//!
//! ## Structured logging
//!
//! If you enable the `kv` feature you can associate structured values
//! with your log records. If we take the example from before, we can include
//! some additional context besides what's in the formatted message:
//!
//! ```
//! # use serde::Serialize;
//! # #[derive(Debug, Serialize)] pub struct Yak(String);
//! # impl Yak { fn shave(&mut self, _: u32) {} }
//! # fn find_a_razor() -> Result<u32, std::io::Error> { Ok(1) }
//! # #[cfg(feature = "kv_serde")]
//! # fn main() {
//! use log::{info, warn};
//!
//! pub fn shave_the_yak(yak: &mut Yak) {
//!     info!(target: "yak_events", yak:serde; "Commencing yak shaving");
//!
//!     loop {
//!         match find_a_razor() {
//!             Ok(razor) => {
//!                 info!(razor; "Razor located");
//!                 yak.shave(razor);
//!                 break;
//!             }
//!             Err(e) => {
//!                 warn!(e:err; "Unable to locate a razor, retrying");
//!             }
//!         }
//!     }
//! }
//! # }
//! # #[cfg(not(feature = "kv_serde"))]
//! # fn main() {}
//! ```
//!
//! See the [`kv`] module documentation for more details.
//!
//! # Available logging implementations
//!
//! In order to produce log output executables have to use
//! a logger implementation compatible with the facade.
//! There are many available implementations to choose from,
//! here are some of the most popular ones:
//!
//! * Simple minimal loggers:
//!     * [env_logger]
//!     * [colog]
//!     * [simple_logger]
//!     * [simplelog]
//!     * [pretty_env_logger]
//!     * [stderrlog]
//!     * [flexi_logger]
//!     * [call_logger]
//!     * [std-logger]
//!     * [structured-logger]
//!     * [clang_log]
//!     * [ftail]
//! * Complex configurable frameworks:
//!     * [log4rs]
//!     * [logforth]
//!     * [fern]
//!     * [spdlog-rs]
//! * Adaptors for other facilities:
//!     * [syslog]
//!     * [slog-stdlog]
//!     * [systemd-journal-logger]
//!     * [android_log]
//!     * [win_dbg_logger]
//!     * [db_logger]
//!     * [log-to-defmt]
//!     * [logcontrol-log]
//! * For WebAssembly binaries:
//!     * [console_log]
//! * For dynamic libraries:
//!     * You may need to construct an FFI-safe wrapper over `log` to initialize in your libraries
//! * Utilities:
//!     * [log_err]
//!     * [log-reload]
//!     * [alterable_logger]
//!
//! # Implementing a Logger
//!
//! Loggers implement the [`Log`] trait. Here's a very basic example that simply
//! logs all messages at the [`Error`][level_link], [`Warn`][level_link] or
//! [`Info`][level_link] levels to stdout:
//!
//! ```
//! use log::{Record, Level, Metadata};
//!
//! struct SimpleLogger;
//!
//! impl log::Log for SimpleLogger {
//!     fn enabled(&self, metadata: &Metadata) -> bool {
//!         metadata.level() <= Level::Info
//!     }
//!
//!     fn log(&self, record: &Record) {
//!         if self.enabled(record.metadata()) {
//!             println!("{} - {}", record.level(), record.args());
//!         }
//!     }
//!
//!     fn flush(&self) {}
//! }
//!
//! # fn main() {}
//! ```
//!
//! Loggers are installed by calling the [`set_logger`] function. The maximum
//! log level also needs to be adjusted via the [`set_max_level`] function. The
//! logging facade uses this as an optimization to improve performance of log
//! messages at levels that are disabled. It's important to set it, as it
//! defaults to [`Off`][filter_link], so no log messages will ever be captured!
//! In the case of our example logger, we'll want to set the maximum log level
//! to [`Info`][filter_link], since we ignore any [`Debug`][level_link] or
//! [`Trace`][level_link] level log messages. A logging implementation should
//! provide a function that wraps a call to [`set_logger`] and
//! [`set_max_level`], handling initialization of the logger:
//!
//! ```
//! # use log::{Level, Metadata};
//! # struct SimpleLogger;
//! # impl log::Log for SimpleLogger {
//! #   fn enabled(&self, _: &Metadata) -> bool { false }
//! #   fn log(&self, _: &log::Record) {}
//! #   fn flush(&self) {}
//! # }
//! # fn main() {}
//! use log::{SetLoggerError, LevelFilter};
//!
//! static LOGGER: SimpleLogger = SimpleLogger;
//!
//! pub fn init() -> Result<(), SetLoggerError> {
//!     log::set_logger(&LOGGER)
//!         .map(|()| log::set_max_level(LevelFilter::Info))
//! }
//! ```
//!
//! Implementations that adjust their configurations at runtime should take care
//! to adjust the maximum log level as well.
//!
//! # Use with `std`
//!
//! `set_logger` requires you to provide a `&'static Log`, which can be hard to
//! obtain if your logger depends on some runtime configuration. The
//! `set_boxed_logger` function is available with the `std` Cargo feature. It is
//! identical to `set_logger` except that it takes a `Box<Log>` rather than a
//! `&'static Log`:
//!
//! ```
//! # use log::{Level, LevelFilter, Log, SetLoggerError, Metadata};
//! # struct SimpleLogger;
//! # impl log::Log for SimpleLogger {
//! #   fn enabled(&self, _: &Metadata) -> bool { false }
//! #   fn log(&self, _: &log::Record) {}
//! #   fn flush(&self) {}
//! # }
//! # fn main() {}
//! # #[cfg(feature = "std")]
//! pub fn init() -> Result<(), SetLoggerError> {
//!     log::set_boxed_logger(Box::new(SimpleLogger))
//!         .map(|()| log::set_max_level(LevelFilter::Info))
//! }
//! ```
//!
//! # Compile time filters
//!
//! Log levels can be statically disabled at compile time by enabling one of these Cargo features:
//!
//! * `max_level_off`
//! * `max_level_error`
//! * `max_level_warn`
//! * `max_level_info`
//! * `max_level_debug`
//! * `max_level_trace`
//!
//! Log invocations at disabled levels will be skipped and will not even be present in the
//! resulting binary. These features control the value of the `STATIC_MAX_LEVEL` constant. The
//! logging macros check this value before logging a message. By default, no levels are disabled.
//!
//! It is possible to override this level for release builds only with the following features:
//!
//! * `release_max_level_off`
//! * `release_max_level_error`
//! * `release_max_level_warn`
//! * `release_max_level_info`
//! * `release_max_level_debug`
//! * `release_max_level_trace`
//!
//! Libraries should avoid using the max level features because they're global and can't be changed
//! once they're set.
//!
//! For example, a crate can disable trace level logs in debug builds and trace, debug, and info
//! level logs in release builds with the following configuration:
//!
//! ```toml
//! [dependencies]
//! log = { version = "0.4", features = ["max_level_debug", "release_max_level_warn"] }
//! ```
//! # Crate Feature Flags
//!
//! The following crate feature flags are available in addition to the filters. They are
//! configured in your `Cargo.toml`.
//!
//! * `std` allows use of `std` crate instead of the default `core`. Enables using `std::error` and
//!   `set_boxed_logger` functionality.
//! * `serde` enables support for serialization and deserialization of `Level` and `LevelFilter`.
//!
//! ```toml
//! [dependencies]
//! log = { version = "0.4", features = ["std", "serde"] }
//! ```
//!
//! # Version compatibility
//!
//! The 0.3 and 0.4 versions of the `log` crate are almost entirely compatible. Log messages
//! made using `log` 0.3 will forward transparently to a logger implementation using `log` 0.4. Log
//! messages made using `log` 0.4 will forward to a logger implementation using `log` 0.3, but the
//! module path and file name information associated with the message will unfortunately be lost.
//!
//! [`Log`]: trait.Log.html
//! [level_link]: enum.Level.html
//! [filter_link]: enum.LevelFilter.html
//! [`set_logger`]: fn.set_logger.html
//! [`set_max_level`]: fn.set_max_level.html
//! [`try_set_logger_raw`]: fn.try_set_logger_raw.html
//! [`shutdown_logger_raw`]: fn.shutdown_logger_raw.html
//! [env_logger]: https://docs.rs/env_logger/*/env_logger/
//! [colog]: https://docs.rs/colog/*/colog/
//! [simple_logger]: https://github.com/borntyping/rust-simple_logger
//! [simplelog]: https://github.com/drakulix/simplelog.rs
//! [pretty_env_logger]: https://docs.rs/pretty_env_logger/*/pretty_env_logger/
//! [stderrlog]: https://docs.rs/stderrlog/*/stderrlog/
//! [flexi_logger]: https://docs.rs/flexi_logger/*/flexi_logger/
//! [call_logger]: https://docs.rs/call_logger/*/call_logger/
//! [std-logger]: https://docs.rs/std-logger/*/std_logger/
//! [syslog]: https://docs.rs/syslog/*/syslog/
//! [slog-stdlog]: https://docs.rs/slog-stdlog/*/slog_stdlog/
//! [log4rs]: https://docs.rs/log4rs/*/log4rs/
//! [logforth]: https://docs.rs/logforth/*/logforth/
//! [fern]: https://docs.rs/fern/*/fern/
//! [spdlog-rs]: https://docs.rs/spdlog-rs/*/spdlog/
//! [systemd-journal-logger]: https://docs.rs/systemd-journal-logger/*/systemd_journal_logger/
//! [android_log]: https://docs.rs/android_log/*/android_log/
//! [win_dbg_logger]: https://docs.rs/win_dbg_logger/*/win_dbg_logger/
//! [db_logger]: https://docs.rs/db_logger/*/db_logger/
//! [log-to-defmt]: https://docs.rs/log-to-defmt/*/log_to_defmt/
//! [console_log]: https://docs.rs/console_log/*/console_log/
//! [structured-logger]: https://docs.rs/structured-logger/latest/structured_logger/
//! [logcontrol-log]: https://docs.rs/logcontrol-log/*/logcontrol_log/
//! [log_err]: https://docs.rs/log_err/*/log_err/
//! [log-reload]: https://docs.rs/log-reload/*/log_reload/
//! [alterable_logger]: https://docs.rs/alterable_logger/*/alterable_logger
//! [clang_log]: https://docs.rs/clang_log/latest/clang_log
//! [ftail]: https://docs.rs/ftail/latest/ftail

#![doc(
    html_logo_url = "https://prev.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
    html_favicon_url = "https://prev.rust-lang.org/favicon.ico",
    html_root_url = "https://docs.rs/log/0.4.33"
)]
#![warn(missing_docs)]
#![deny(missing_debug_implementations, unconditional_recursion)]
#![cfg_attr(all(not(feature = "std"), not(test)), no_std)]

#[cfg(any(
    all(feature = "max_level_off", feature = "max_level_error"),
    all(feature = "max_level_off", feature = "max_level_warn"),
    all(feature = "max_level_off", feature = "max_level_info"),
    all(feature = "max_level_off", feature = "max_level_debug"),
    all(feature = "max_level_off", feature = "max_level_trace"),
    all(feature = "max_level_error", feature = "max_level_warn"),
    all(feature = "max_level_error", feature = "max_level_info"),
    all(feature = "max_level_error", feature = "max_level_debug"),
    all(feature = "max_level_error", feature = "max_level_trace"),
    all(feature = "max_level_warn", feature = "max_level_info"),
    all(feature = "max_level_warn", feature = "max_level_debug"),
    all(feature = "max_level_warn", feature = "max_level_trace"),
    all(feature = "max_level_info", feature = "max_level_debug"),
    all(feature = "max_level_info", feature = "max_level_trace"),
    all(feature = "max_level_debug", feature = "max_level_trace"),
))]
compile_error!("multiple max_level_* features set");

#[rustfmt::skip]
#[cfg(any(
    all(feature = "release_max_level_off", feature = "release_max_level_error"),
    all(feature = "release_max_level_off", feature = "release_max_level_warn"),
    all(feature = "release_max_level_off", feature = "release_max_level_info"),
    all(feature = "release_max_level_off", feature = "release_max_level_debug"),
    all(feature = "release_max_level_off", feature = "release_max_level_trace"),
    all(feature = "release_max_level_error", feature = "release_max_level_warn"),
    all(feature = "release_max_level_error", feature = "release_max_level_info"),
    all(feature = "release_max_level_error", feature = "release_max_level_debug"),
    all(feature = "release_max_level_error", feature = "release_max_level_trace"),
    all(feature = "release_max_level_warn", feature = "release_max_level_info"),
    all(feature = "release_max_level_warn", feature = "release_max_level_debug"),
    all(feature = "release_max_level_warn", feature = "release_max_level_trace"),
    all(feature = "release_max_level_info", feature = "release_max_level_debug"),
    all(feature = "release_max_level_info", feature = "release_max_level_trace"),
    all(feature = "release_max_level_debug", feature = "release_max_level_trace"),
))]
compile_error!("multiple release_max_level_* features set");

#[cfg(all(not(feature = "std"), not(test)))]
extern crate core as std;

use std::cfg;
#[cfg(feature = "std")]
use std::error;
use std::str::FromStr;
use std::{cmp, fmt, mem};

#[macro_use]
mod macros;
mod serde;

#[cfg(feature = "kv")]
pub mod kv;

#[cfg(target_has_atomic = "ptr")]
use std::sync::atomic::{AtomicUsize, Ordering};

#[cfg(not(target_has_atomic = "ptr"))]
use std::cell::Cell;
#[cfg(not(target_has_atomic = "ptr"))]
use std::sync::atomic::Ordering;

#[cfg(not(target_has_atomic = "ptr"))]
struct AtomicUsize {
    v: Cell<usize>,
}

#[cfg(not(target_has_atomic = "ptr"))]
impl AtomicUsize {
    const fn new(v: usize) -> AtomicUsize {
        AtomicUsize { v: Cell::new(v) }
    }

    fn load(&self, _order: Ordering) -> usize {
        self.v.get()
    }

    fn store(&self, val: usize, _order: Ordering) {
        self.v.set(val)
    }
}

// Any platform without atomics is unlikely to have multiple cores, so
// writing via Cell will not be a race condition.
#[cfg(not(target_has_atomic = "ptr"))]
unsafe impl Sync for AtomicUsize {}

// The LOGGER static holds a pointer to the global logger. It is protected by
// the STATE static which determines whether LOGGER has been initialized yet.
static mut LOGGER: &dyn Log = &NopLogger;

static STATE: AtomicUsize = AtomicUsize::new(0);

// There are three different states that we care about: the logger's
// uninitialized, the logger's initializing (set_logger's been called but
// LOGGER hasn't actually been set yet), or the logger's active.
const UNINITIALIZED: usize = 0;
const INITIALIZING: usize = 1;
const INITIALIZED: usize = 2;

static MAX_LOG_LEVEL_FILTER: AtomicUsize = AtomicUsize::new(0);

static LOG_LEVEL_NAMES: [&str; 6] = ["OFF", "ERROR", "WARN", "INFO", "DEBUG", "TRACE"];

static SET_LOGGER_ERROR: &str = "attempted to set a logger after the logging system \
                                 was already initialized";
static LEVEL_PARSE_ERROR: &str =
    "attempted to convert a string that doesn't match an existing log level";

/// An enum representing the available verbosity levels of the logger.
///
/// Typical usage includes: checking if a certain `Level` is enabled with
/// [`log_enabled!`](macro.log_enabled.html), specifying the `Level` of
/// [`log!`](macro.log.html), and comparing a `Level` directly to a
/// [`LevelFilter`](enum.LevelFilter.html).
#[repr(usize)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Debug, Hash)]
pub enum Level {
    /// The "error" level.
    ///
    /// Designates very serious errors.
    // This way these line up with the discriminants for LevelFilter below
    // This works because Rust treats field-less enums the same way as C does:
    // https://doc.rust-lang.org/reference/items/enumerations.html#custom-discriminant-values-for-field-less-enumerations
    Error = 1,
    /// The "warn" level.
    ///
    /// Designates hazardous situations.
    Warn,
    /// The "info" level.
    ///
    /// Designates useful information.
    Info,
    /// The "debug" level.
    ///
    /// Designates lower priority information.
    Debug,
    /// The "trace" level.
    ///
    /// Designates very low priority, often extremely verbose, information.
    Trace,
}

impl PartialEq<LevelFilter> for Level {
    #[inline]
    fn eq(&self, other: &LevelFilter) -> bool {
        *self as usize == *other as usize
    }
}

impl PartialOrd<LevelFilter> for Level {
    #[inline]
    fn partial_cmp(&self, other: &LevelFilter) -> Option<cmp::Ordering> {
        Some((*self as usize).cmp(&(*other as usize)))
    }
}

impl FromStr for Level {
    type Err = ParseLevelError;
    fn from_str(level: &str) -> Result<Level, Self::Err> {
        // iterate from 1, excluding "OFF"
        for idx in 1..LOG_LEVEL_NAMES.len() {
            if LOG_LEVEL_NAMES[idx].eq_ignore_ascii_case(level) {
                return Ok(Level::from_usize(idx).unwrap());
            }
        }
        Err(ParseLevelError(()))
    }
}

impl fmt::Display for Level {
    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
        fmt.pad(self.as_str())
    }
}

impl Level {
    fn from_usize(u: usize) -> Option<Level> {
        match u {
            1 => Some(Level::Error),
            2 => Some(Level::Warn),
            3 => Some(Level::Info),
            4 => Some(Level::Debug),
            5 => Some(Level::Trace),
            _ => None,
        }
    }

    /// Returns the most verbose logging level.
    #[inline]
    pub fn max() -> Level {
        Level::Trace
    }

    /// Converts the `Level` to the equivalent `LevelFilter`.
    #[inline]
    pub fn to_level_filter(&self) -> LevelFilter {
        LevelFilter::from_usize(*self as usize).unwrap()
    }

    /// Returns the string representation of the `Level`.
    ///
    /// This returns the same string as the `fmt::Display` implementation.
    pub fn as_str(&self) -> &'static str {
        LOG_LEVEL_NAMES[*self as usize]
    }

    /// Iterate through all supported logging levels.
    ///
    /// The order of iteration is from more severe to less severe log messages.
    ///
    /// # Examples
    ///
    /// ```
    /// use log::Level;
    ///
    /// let mut levels = Level::iter();
    ///
    /// assert_eq!(Some(Level::Error), levels.next());
    /// assert_eq!(Some(Level::Trace), levels.last());
    /// ```
    pub fn iter() -> impl Iterator<Item = Self> {
        (1..6).map(|i| Self::from_usize(i).unwrap())
    }

    /// Get the next-highest `Level` from this one.
    ///
    /// If the current `Level` is at the highest level, the returned `Level` will be the same as the
    /// current one.
    ///
    /// # Examples
    ///
    /// ```
    /// use log::Level;
    ///
    /// let level = Level::Info;
    ///
    /// assert_eq!(Level::Debug, level.increment_severity());
    /// assert_eq!(Level::Trace, level.increment_severity().increment_severity());
    /// assert_eq!(Level::Trace, level.increment_severity().increment_severity().increment_severity()); // max level
    /// ```
    pub fn increment_severity(&self) -> Self {
        let current = *self as usize;
        Self::from_usize(current + 1).unwrap_or(*self)
    }

    /// Get the next-lowest `Level` from this one.
    ///
    /// If the current `Level` is at the lowest level, the returned `Level` will be the same as the
    /// current one.
    ///
    /// # Examples
    ///
    /// ```
    /// use log::Level;
    ///
    /// let level = Level::Info;
    ///
    /// assert_eq!(Level::Warn, level.decrement_severity());
    /// assert_eq!(Level::Error, level.decrement_severity().decrement_severity());
    /// assert_eq!(Level::Error, level.decrement_severity().decrement_severity().decrement_severity()); // min level
    /// ```
    pub fn decrement_severity(&self) -> Self {
        let current = *self as usize;
        Self::from_usize(current.saturating_sub(1)).unwrap_or(*self)
    }
}

/// An enum representing the available verbosity level filters of the logger.
///
/// A `LevelFilter` may be compared directly to a [`Level`]. Use this type
/// to get and set the maximum log level with [`max_level()`] and [`set_max_level`].
///
/// [`Level`]: enum.Level.html
/// [`max_level()`]: fn.max_level.html
/// [`set_max_level`]: fn.set_max_level.html
#[repr(usize)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Debug, Hash)]
pub enum LevelFilter {
    /// A level lower than all log levels.
    Off,
    /// Corresponds to the `Error` log level.
    Error,
    /// Corresponds to the `Warn` log level.
    Warn,
    /// Corresponds to the `Info` log level.
    Info,
    /// Corresponds to the `Debug` log level.
    Debug,
    /// Corresponds to the `Trace` log level.
    Trace,
}

impl PartialEq<Level> for LevelFilter {
    #[inline]
    fn eq(&self, other: &Level) -> bool {
        other.eq(self)
    }
}

impl PartialOrd<Level> for LevelFilter {
    #[inline]
    fn partial_cmp(&self, other: &Level) -> Option<cmp::Ordering> {
        Some((*self as usize).cmp(&(*other as usize)))
    }
}

impl FromStr for LevelFilter {
    type Err = ParseLevelError;
    fn from_str(level: &str) -> Result<LevelFilter, Self::Err> {
        // iterate from 0, including "OFF"
        for idx in 0..LOG_LEVEL_NAMES.len() {
            if LOG_LEVEL_NAMES[idx].eq_ignore_ascii_case(level) {
                return Ok(LevelFilter::from_usize(idx).unwrap());
            }
        }
        Err(ParseLevelError(()))
    }
}

impl fmt::Display for LevelFilter {
    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
        fmt.pad(self.as_str())
    }
}

impl LevelFilter {
    fn from_usize(u: usize) -> Option<LevelFilter> {
        match u {
            0 => Some(LevelFilter::Off),
            1 => Some(LevelFilter::Error),
            2 => Some(LevelFilter::Warn),
            3 => Some(LevelFilter::Info),
            4 => Some(LevelFilter::Debug),
            5 => Some(LevelFilter::Trace),
            _ => None,
        }
    }

    /// Returns the most verbose logging level filter.
    #[inline]
    pub fn max() -> LevelFilter {
        LevelFilter::Trace
    }

    /// Converts `self` to the equivalent `Level`.
    ///
    /// Returns `None` if `self` is `LevelFilter::Off`.
    #[inline]
    pub fn to_level(&self) -> Option<Level> {
        Level::from_usize(*self as usize)
    }

    /// Returns the string representation of the `LevelFilter`.
    ///
    /// This returns the same string as the `fmt::Display` implementation.
    pub fn as_str(&self) -> &'static str {
        LOG_LEVEL_NAMES[*self as usize]
    }

    /// Iterate through all supported filtering levels.
    ///
    /// The order of iteration is from less to more verbose filtering.
    ///
    /// # Examples
    ///
    /// ```
    /// use log::LevelFilter;
    ///
    /// let mut levels = LevelFilter::iter();
    ///
    /// assert_eq!(Some(LevelFilter::Off), levels.next());
    /// assert_eq!(Some(LevelFilter::Trace), levels.last());
    /// ```
    pub fn iter() -> impl Iterator<Item = Self> {
        (0..6).map(|i| Self::from_usize(i).unwrap())
    }

    /// Get the next-highest `LevelFilter` from this one.
    ///
    /// If the current `LevelFilter` is at the highest level, the returned `LevelFilter` will be the
    /// same as the current one.
    ///
    /// # Examples
    ///
    /// ```
    /// use log::LevelFilter;
    ///
    /// let level_filter = LevelFilter::Info;
    ///
    /// assert_eq!(LevelFilter::Debug, level_filter.increment_severity());
    /// assert_eq!(LevelFilter::Trace, level_filter.increment_severity().increment_severity());
    /// assert_eq!(LevelFilter::Trace, level_filter.increment_severity().increment_severity().increment_severity()); // max level
    /// ```
    pub fn increment_severity(&self) -> Self {
        let current = *self as usize;
        Self::from_usize(current + 1).unwrap_or(*self)
    }

    /// Get the next-lowest `LevelFilter` from this one.
    ///
    /// If the current `LevelFilter` is at the lowest level, the returned `LevelFilter` will be the
    /// same as the current one.
    ///
    /// # Examples
    ///
    /// ```
    /// use log::LevelFilter;
    ///
    /// let level_filter = LevelFilter::Info;
    ///
    /// assert_eq!(LevelFilter::Warn, level_filter.decrement_severity());
    /// assert_eq!(LevelFilter::Error, level_filter.decrement_severity().decrement_severity());
    /// assert_eq!(LevelFilter::Off, level_filter.decrement_severity().decrement_severity().decrement_severity());
    /// assert_eq!(LevelFilter::Off, level_filter.decrement_severity().decrement_severity().decrement_severity().decrement_severity()); // min level
    /// ```
    pub fn decrement_severity(&self) -> Self {
        let current = *self as usize;
        Self::from_usize(current.saturating_sub(1)).unwrap_or(*self)
    }
}

#[derive(Copy, Clone, Debug)]
enum MaybeStaticStr<'a> {
    Static(&'static str),
    Borrowed(&'a str),
}

impl<'a> MaybeStaticStr<'a> {
    #[inline]
    fn get(&self) -> &'a str {
        match *self {
            MaybeStaticStr::Static(s) => s,
            MaybeStaticStr::Borrowed(s) => s,
        }
    }
}

impl Eq for MaybeStaticStr<'_> {}

impl PartialEq for MaybeStaticStr<'_> {
    fn eq(&self, other: &Self) -> bool {
        self.get() == other.get()
    }
}

impl Ord for MaybeStaticStr<'_> {
    fn cmp(&self, other: &Self) -> core::cmp::Ordering {
        self.get().cmp(other.get())
    }
}

impl PartialOrd for MaybeStaticStr<'_> {
    fn partial_cmp(&self, other: &Self) -> Option<core::cmp::Ordering> {
        Some(self.cmp(other))
    }
}

impl std::hash::Hash for MaybeStaticStr<'_> {
    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
        self.get().hash(state);
    }
}

/// The "payload" of a log message.
///
/// # Use
///
/// `Record` structures are passed as parameters to the [`log`][method.log]
/// method of the [`Log`] trait. Logger implementors manipulate these
/// structures in order to display log messages. `Record`s are automatically
/// created by the [`log!`] macro and so are not seen by log users.
///
/// Note that the [`level()`] and [`target()`] accessors are equivalent to
/// `self.metadata().level()` and `self.metadata().target()` respectively.
/// These methods are provided as a convenience for users of this structure.
///
/// # Example
///
/// The following example shows a simple logger that displays the level,
/// module path, and message of any `Record` that is passed to it.
///
/// ```
/// struct SimpleLogger;
///
/// impl log::Log for SimpleLogger {
///    fn enabled(&self, _metadata: &log::Metadata) -> bool {
///        true
///    }
///
///    fn log(&self, record: &log::Record) {
///        if !self.enabled(record.metadata()) {
///            return;
///        }
///
///        println!("{}:{} -- {}",
///                 record.level(),
///                 record.target(),
///                 record.args());
///    }
///    fn flush(&self) {}
/// }
/// ```
///
/// [method.log]: trait.Log.html#tymethod.log
/// [`Log`]: trait.Log.html
/// [`log!`]: macro.log.html
/// [`level()`]: struct.Record.html#method.level
/// [`target()`]: struct.Record.html#method.target
#[derive(Clone, Debug)]
pub struct Record<'a> {
    metadata: Metadata<'a>,
    args: fmt::Arguments<'a>,
    module_path: Option<MaybeStaticStr<'a>>,
    file: Option<MaybeStaticStr<'a>>,
    line: Option<u32>,
    #[cfg(feature = "kv")]
    key_values: KeyValues<'a>,
}

// This wrapper type is only needed so we can
// `#[derive(Debug)]` on `Record`. It also
// provides a useful `Debug` implementation for
// the underlying `Source`.
#[cfg(feature = "kv")]
#[derive(Clone)]
struct KeyValues<'a>(&'a dyn kv::Source);

#[cfg(feature = "kv")]
impl<'a> fmt::Debug for KeyValues<'a> {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        let mut visitor = f.debug_map();
        self.0.visit(&mut visitor).map_err(|_| fmt::Error)?;
        visitor.finish()
    }
}

impl<'a> Record<'a> {
    /// Returns a new builder.
    #[inline]
    pub fn builder() -> RecordBuilder<'a> {
        RecordBuilder::new()
    }

    /// The message body.
    #[inline]
    pub fn args(&self) -> &fmt::Arguments<'a> {
        &self.args
    }

    /// Metadata about the log directive.
    #[inline]
    pub fn metadata(&self) -> &Metadata<'a> {
        &self.metadata
    }

    /// The verbosity level of the message.
    #[inline]
    pub fn level(&self) -> Level {
        self.metadata.level()
    }

    /// The name of the target of the directive.
    #[inline]
    pub fn target(&self) -> &'a str {
        self.metadata.target()
    }

    /// The module path of the message.
    #[inline]
    pub fn module_path(&self) -> Option<&'a str> {
        self.module_path.map(|s| s.get())
    }

    /// The module path of the message, if it is a `'static` string.
    #[inline]
    pub fn module_path_static(&self) -> Option<&'static str> {
        match self.module_path {
            Some(MaybeStaticStr::Static(s)) => Some(s),
            _ => None,
        }
    }

    /// The source file containing the message.
    #[inline]
    pub fn file(&self) -> Option<&'a str> {
        self.file.map(|s| s.get())
    }

    /// The source file containing the message, if it is a `'static` string.
    #[inline]
    pub fn file_static(&self) -> Option<&'static str> {
        match self.file {
            Some(MaybeStaticStr::Static(s)) => Some(s),
            _ => None,
        }
    }

    /// The line containing the message.
    #[inline]
    pub fn line(&self) -> Option<u32> {
        self.line
    }

    /// The structured key-value pairs associated with the message.
    #[cfg(feature = "kv")]
    #[inline]
    pub fn key_values(&self) -> &dyn kv::Source {
        self.key_values.0
    }

    /// Create a new [`RecordBuilder`](struct.RecordBuilder.html) based on this record.
    #[cfg(feature = "kv")]
    #[inline]
    pub fn to_builder(&self) -> RecordBuilder<'_> {
        RecordBuilder {
            record: Record {
                metadata: Metadata {
                    level: self.metadata.level,
                    target: self.metadata.target,
                },
                args: self.args,
                module_path: self.module_path,
                file: self.file,
                line: self.line,
                key_values: self.key_values.clone(),
            },
        }
    }
}

/// Builder for [`Record`](struct.Record.html).
///
/// Typically should only be used by log library creators or for testing and "shim loggers".
/// The `RecordBuilder` can set the different parameters of `Record` object, and returns
/// the created object when `build` is called.
///
/// # Examples
///
/// ```
/// use log::{Level, Record};
///
/// let record = Record::builder()
///                 .args(format_args!("Error!"))
///                 .level(Level::Error)
///                 .target("myApp")
///                 .file(Some("server.rs"))
///                 .line(Some(144))
///                 .module_path(Some("server"))
///                 .build();
/// ```
///
/// Alternatively, use [`MetadataBuilder`](struct.MetadataBuilder.html):
///
/// ```
/// use log::{Record, Level, MetadataBuilder};
///
/// let error_metadata = MetadataBuilder::new()
///                         .target("myApp")
///                         .level(Level::Error)
///                         .build();
///
/// let record = Record::builder()
///                 .metadata(error_metadata)
///                 .args(format_args!("Error!"))
///                 .line(Some(433))
///                 .file(Some("app.rs"))
///                 .module_path(Some("server"))
///                 .build();
/// ```
#[derive(Debug)]
pub struct RecordBuilder<'a> {
    record: Record<'a>,
}

impl<'a> RecordBuilder<'a> {
    /// Construct new `RecordBuilder`.
    ///
    /// The default options are:
    ///
    /// - `args`: [`format_args!("")`]
    /// - `metadata`: [`Metadata::builder().build()`]
    /// - `module_path`: `None`
    /// - `file`: `None`
    /// - `line`: `None`
    ///
    /// [`format_args!("")`]: https://doc.rust-lang.org/std/macro.format_args.html
    /// [`Metadata::builder().build()`]: struct.MetadataBuilder.html#method.build
    #[inline]
    pub fn new() -> RecordBuilder<'a> {
        RecordBuilder {
            record: Record {
                args: format_args!(""),
                metadata: Metadata::builder().build(),
                module_path: None,
                file: None,
                line: None,
                #[cfg(feature = "kv")]
                key_values: KeyValues(&None::<(kv::Key, kv::Value)>),
            },
        }
    }

    /// Set [`args`](struct.Record.html#method.args).
    #[inline]
    pub fn args(&mut self, args: fmt::Arguments<'a>) -> &mut RecordBuilder<'a> {
        self.record.args = args;
        self
    }

    /// Set [`metadata`](struct.Record.html#method.metadata). Construct a `Metadata` object with [`MetadataBuilder`](struct.MetadataBuilder.html).
    #[inline]
    pub fn metadata(&mut self, metadata: Metadata<'a>) -> &mut RecordBuilder<'a> {
        self.record.metadata = metadata;
        self
    }

    /// Set [`Metadata::level`](struct.Metadata.html#method.level).
    #[inline]
    pub fn level(&mut self, level: Level) -> &mut RecordBuilder<'a> {
        self.record.metadata.level = level;
        self
    }

    /// Set [`Metadata::target`](struct.Metadata.html#method.target)
    #[inline]
    pub fn target(&mut self, target: &'a str) -> &mut RecordBuilder<'a> {
        self.record.metadata.target = target;
        self
    }

    /// Set [`module_path`](struct.Record.html#method.module_path)
    #[inline]
    pub fn module_path(&mut self, path: Option<&'a str>) -> &mut RecordBuilder<'a> {
        self.record.module_path = path.map(MaybeStaticStr::Borrowed);
        self
    }

    /// Set [`module_path`](struct.Record.html#method.module_path) to a `'static` string
    #[inline]
    pub fn module_path_static(&mut self, path: Option<&'static str>) -> &mut RecordBuilder<'a> {
        self.record.module_path = path.map(MaybeStaticStr::Static);
        self
    }

    /// Set [`file`](struct.Record.html#method.file)
    #[inline]
    pub fn file(&mut self, file: Option<&'a str>) -> &mut RecordBuilder<'a> {
        self.record.file = file.map(MaybeStaticStr::Borrowed);
        self
    }

    /// Set [`file`](struct.Record.html#method.file) to a `'static` string.
    #[inline]
    pub fn file_static(&mut self, file: Option<&'static str>) -> &mut RecordBuilder<'a> {
        self.record.file = file.map(MaybeStaticStr::Static);
        self
    }

    /// Set [`line`](struct.Record.html#method.line)
    #[inline]
    pub fn line(&mut self, line: Option<u32>) -> &mut RecordBuilder<'a> {
        self.record.line = line;
        self
    }

    /// Set [`key_values`](struct.Record.html#method.key_values)
    #[cfg(feature = "kv")]
    #[inline]
    pub fn key_values(&mut self, kvs: &'a dyn kv::Source) -> &mut RecordBuilder<'a> {
        self.record.key_values = KeyValues(kvs);
        self
    }

    /// Invoke the builder and return a `Record`
    #[inline]
    pub fn build(&self) -> Record<'a> {
        self.record.clone()
    }
}

impl Default for RecordBuilder<'_> {
    fn default() -> Self {
        Self::new()
    }
}

/// Metadata about a log message.
///
/// # Use
///
/// `Metadata` structs are created when users of the library use
/// logging macros.
///
/// They are consumed by implementations of the `Log` trait in the
/// `enabled` method.
///
/// `Record`s use `Metadata` to determine the log message's severity
/// and target.
///
/// Users should use the `log_enabled!` macro in their code to avoid
/// constructing expensive log messages.
///
/// # Examples
///
/// ```
/// use log::{Record, Level, Metadata};
///
/// struct MyLogger;
///
/// impl log::Log for MyLogger {
///     fn enabled(&self, metadata: &Metadata) -> bool {
///         metadata.level() <= Level::Info
///     }
///
///     fn log(&self, record: &Record) {
///         if self.enabled(record.metadata()) {
///             println!("{} - {}", record.level(), record.args());
///         }
///     }
///     fn flush(&self) {}
/// }
///
/// # fn main(){}
/// ```
#[derive(Clone, Eq, PartialEq, Ord, PartialOrd, Hash, Debug)]
pub struct Metadata<'a> {
    level: Level,
    target: &'a str,
}

impl<'a> Metadata<'a> {
    /// Returns a new builder.
    #[inline]
    pub fn builder() -> MetadataBuilder<'a> {
        MetadataBuilder::new()
    }

    /// The verbosity level of the message.
    #[inline]
    pub fn level(&self) -> Level {
        self.level
    }

    /// The name of the target of the directive.
    #[inline]
    pub fn target(&self) -> &'a str {
        self.target
    }
}

/// Builder for [`Metadata`](struct.Metadata.html).
///
/// Typically should only be used by log library creators or for testing and "shim loggers".
/// The `MetadataBuilder` can set the different parameters of a `Metadata` object, and returns
/// the created object when `build` is called.
///
/// # Example
///
/// ```
/// let target = "myApp";
/// use log::{Level, MetadataBuilder};
/// let metadata = MetadataBuilder::new()
///                     .level(Level::Debug)
///                     .target(target)
///                     .build();
/// ```
#[derive(Eq, PartialEq, Ord, PartialOrd, Hash, Debug)]
pub struct MetadataBuilder<'a> {
    metadata: Metadata<'a>,
}

impl<'a> MetadataBuilder<'a> {
    /// Construct a new `MetadataBuilder`.
    ///
    /// The default options are:
    ///
    /// - `level`: `Level::Info`
    /// - `target`: `""`
    #[inline]
    pub fn new() -> MetadataBuilder<'a> {
        MetadataBuilder {
            metadata: Metadata {
                level: Level::Info,
                target: "",
            },
        }
    }

    /// Setter for [`level`](struct.Metadata.html#method.level).
    #[inline]
    pub fn level(&mut self, arg: Level) -> &mut MetadataBuilder<'a> {
        self.metadata.level = arg;
        self
    }

    /// Setter for [`target`](struct.Metadata.html#method.target).
    #[inline]
    pub fn target(&mut self, target: &'a str) -> &mut MetadataBuilder<'a> {
        self.metadata.target = target;
        self
    }

    /// Returns a `Metadata` object.
    #[inline]
    pub fn build(&self) -> Metadata<'a> {
        self.metadata.clone()
    }
}

impl Default for MetadataBuilder<'_> {
    fn default() -> Self {
        Self::new()
    }
}

/// A trait encapsulating the operations required of a logger.
pub trait Log: Sync + Send {
    /// Determines if a log message with the specified metadata would be
    /// logged.
    ///
    /// This is used by the `log_enabled!` macro to allow callers to avoid
    /// expensive computation of log message arguments if the message would be
    /// discarded anyway.
    ///
    /// # For implementors
    ///
    /// This method isn't called automatically by the `log!` macros.
    /// It's up to an implementation of the `Log` trait to call `enabled` in its own
    /// `log` method implementation to guarantee that filtering is applied.
    fn enabled(&self, metadata: &Metadata) -> bool;

    /// Logs the `Record`.
    ///
    /// # For implementors
    ///
    /// Note that `enabled` is *not* necessarily called before this method.
    /// Implementations of `log` should perform all necessary filtering
    /// internally.
    fn log(&self, record: &Record);

    /// Flushes any buffered records.
    ///
    /// # For implementors
    ///
    /// This method isn't called automatically by the `log!` macros.
    /// It can be called manually on shut-down to ensure any in-flight records are flushed.
    fn flush(&self);
}

/// A dummy initial value for LOGGER.
struct NopLogger;

impl Log for NopLogger {
    fn enabled(&self, _: &Metadata) -> bool {
        false
    }

    fn log(&self, _: &Record) {}
    fn flush(&self) {}
}

impl<T> Log for &'_ T
where
    T: ?Sized + Log,
{
    fn enabled(&self, metadata: &Metadata) -> bool {
        (**self).enabled(metadata)
    }

    fn log(&self, record: &Record) {
        (**self).log(record);
    }
    fn flush(&self) {
        (**self).flush();
    }
}

#[cfg(feature = "std")]
impl<T> Log for std::boxed::Box<T>
where
    T: ?Sized + Log,
{
    fn enabled(&self, metadata: &Metadata) -> bool {
        self.as_ref().enabled(metadata)
    }

    fn log(&self, record: &Record) {
        self.as_ref().log(record);
    }
    fn flush(&self) {
        self.as_ref().flush();
    }
}

#[cfg(feature = "std")]
impl<T> Log for std::sync::Arc<T>
where
    T: ?Sized + Log,
{
    fn enabled(&self, metadata: &Metadata) -> bool {
        self.as_ref().enabled(metadata)
    }

    fn log(&self, record: &Record) {
        self.as_ref().log(record);
    }
    fn flush(&self) {
        self.as_ref().flush();
    }
}

/// Sets the global maximum log level.
///
/// Generally, this should only be called by the active logging implementation.
///
/// Note that `Trace` is the maximum level, because it provides the maximum amount of detail in the emitted logs.
#[inline]
#[cfg(target_has_atomic = "ptr")]
pub fn set_max_level(level: LevelFilter) {
    MAX_LOG_LEVEL_FILTER.store(level as usize, Ordering::Relaxed);
}

/// A thread-unsafe version of [`set_max_level`].
///
/// This function is available on all platforms, even those that do not have
/// support for atomics that is needed by [`set_max_level`].
///
/// In almost all cases, [`set_max_level`] should be preferred.
///
/// # Safety
///
/// This function is only safe to call when it cannot race with any other
/// calls to `set_max_level` or `set_max_level_racy`.
///
/// This can be upheld by (for example) making sure that **there are no other
/// threads**, and (on embedded) that **interrupts are disabled**.
///
/// It is safe to use all other logging functions while this function runs
/// (including all logging macros).
///
/// [`set_max_level`]: fn.set_max_level.html
#[inline]
pub unsafe fn set_max_level_racy(level: LevelFilter) {
    // `MAX_LOG_LEVEL_FILTER` uses a `Cell` as the underlying primitive when a
    // platform doesn't support `target_has_atomic = "ptr"`, so even though this looks the same
    // as `set_max_level` it may have different safety properties.
    MAX_LOG_LEVEL_FILTER.store(level as usize, Ordering::Relaxed);
}

/// Returns the current maximum log level.
///
/// The [`log!`], [`error!`], [`warn!`], [`info!`], [`debug!`], and [`trace!`] macros check
/// this value and discard any message logged at a higher level. The maximum
/// log level is set by the [`set_max_level`] function.
///
/// [`log!`]: macro.log.html
/// [`error!`]: macro.error.html
/// [`warn!`]: macro.warn.html
/// [`info!`]: macro.info.html
/// [`debug!`]: macro.debug.html
/// [`trace!`]: macro.trace.html
/// [`set_max_level`]: fn.set_max_level.html
#[inline(always)]
pub fn max_level() -> LevelFilter {
    // Since `LevelFilter` is `repr(usize)`,
    // this transmute is sound if and only if `MAX_LOG_LEVEL_FILTER`
    // is set to a usize that is a valid discriminant for `LevelFilter`.
    // Since `MAX_LOG_LEVEL_FILTER` is private, the only time it's set
    // is by `set_max_level` above, i.e. by casting a `LevelFilter` to `usize`.
    // So any usize stored in `MAX_LOG_LEVEL_FILTER` is a valid discriminant.
    unsafe { mem::transmute(MAX_LOG_LEVEL_FILTER.load(Ordering::Relaxed)) }
}

/// Sets the global logger to a `Box<Log>`.
///
/// This is a simple convenience wrapper over `set_logger`, which takes a
/// `Box<Log>` rather than a `&'static Log`. See the documentation for
/// [`set_logger`] for more details.
///
/// Requires the `std` feature.
///
/// # Errors
///
/// An error is returned if a logger has already been set.
///
/// [`set_logger`]: fn.set_logger.html
#[cfg(all(feature = "std", target_has_atomic = "ptr"))]
pub fn set_boxed_logger(logger: Box<dyn Log>) -> Result<(), SetLoggerError> {
    set_logger_inner(|| Box::leak(logger))
}

/// Sets the global logger to a `&'static Log`.
///
/// This function may only be called once in the lifetime of a program. Any log
/// events that occur before the call to `set_logger` completes will be ignored.
///
/// This function does not typically need to be called manually. Logger
/// implementations should provide an initialization method that installs the
/// logger internally.
///
/// # Availability
///
/// This method is available even when the `std` feature is disabled. However,
/// it is currently unavailable on `thumbv6` targets, which lack support for
/// some atomic operations which are used by this function. Even on those
/// targets, [`set_logger_racy`] will be available.
///
/// # Errors
///
/// An error is returned if a logger has already been set.
///
/// # Examples
///
/// ```
/// use log::{error, info, warn, Record, Level, Metadata, LevelFilter};
///
/// static MY_LOGGER: MyLogger = MyLogger;
///
/// struct MyLogger;
///
/// impl log::Log for MyLogger {
///     fn enabled(&self, metadata: &Metadata) -> bool {
///         metadata.level() <= Level::Info
///     }
///
///     fn log(&self, record: &Record) {
///         if self.enabled(record.metadata()) {
///             println!("{} - {}", record.level(), record.args());
///         }
///     }
///     fn flush(&self) {}
/// }
///
/// # fn main(){
/// log::set_logger(&MY_LOGGER).unwrap();
/// log::set_max_level(LevelFilter::Info);
///
/// info!("hello log");
/// warn!("warning");
/// error!("oops");
/// # }
/// ```
///
/// [`set_logger_racy`]: fn.set_logger_racy.html
#[cfg(target_has_atomic = "ptr")]
pub fn set_logger(logger: &'static dyn Log) -> Result<(), SetLoggerError> {
    set_logger_inner(|| logger)
}

#[cfg(target_has_atomic = "ptr")]
fn set_logger_inner<F>(make_logger: F) -> Result<(), SetLoggerError>
where
    F: FnOnce() -> &'static dyn Log,
{
    match STATE.compare_exchange(
        UNINITIALIZED,
        INITIALIZING,
        Ordering::Acquire,
        Ordering::Relaxed,
    ) {
        Ok(UNINITIALIZED) => {
            unsafe {
                LOGGER = make_logger();
            }
            STATE.store(INITIALIZED, Ordering::Release);
            Ok(())
        }
        Err(INITIALIZING) => {
            while STATE.load(Ordering::Relaxed) == INITIALIZING {
                std::hint::spin_loop();
            }
            Err(SetLoggerError(()))
        }
        _ => Err(SetLoggerError(())),
    }
}

/// A thread-unsafe version of [`set_logger`].
///
/// This function is available on all platforms, even those that do not have
/// support for atomics that is needed by [`set_logger`].
///
/// In almost all cases, [`set_logger`] should be preferred.
///
/// # Safety
///
/// This function is only safe to call when it cannot race with any other
/// calls to `set_logger` or `set_logger_racy`.
///
/// This can be upheld by (for example) making sure that **there are no other
/// threads**, and (on embedded) that **interrupts are disabled**.
///
/// It is safe to use other logging functions while this function runs
/// (including all logging macros).
///
/// [`set_logger`]: fn.set_logger.html
pub unsafe fn set_logger_racy(logger: &'static dyn Log) -> Result<(), SetLoggerError> {
    match STATE.load(Ordering::Acquire) {
        UNINITIALIZED => {
            LOGGER = logger;
            STATE.store(INITIALIZED, Ordering::Release);
            Ok(())
        }
        INITIALIZING => {
            // This is just plain UB, since we were racing another initialization function
            unreachable!("set_logger_racy must not be used with other initialization functions")
        }
        _ => Err(SetLoggerError(())),
    }
}

/// The type returned by [`set_logger`] if [`set_logger`] has already been called.
///
/// [`set_logger`]: fn.set_logger.html
#[allow(missing_copy_implementations)]
#[derive(Debug)]
pub struct SetLoggerError(());

impl fmt::Display for SetLoggerError {
    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
        fmt.write_str(SET_LOGGER_ERROR)
    }
}

// The Error trait is not available in libcore
#[cfg(feature = "std")]
impl error::Error for SetLoggerError {}

/// The type returned by [`from_str`] when the string doesn't match any of the log levels.
///
/// [`from_str`]: https://doc.rust-lang.org/std/str/trait.FromStr.html#tymethod.from_str
#[allow(missing_copy_implementations)]
#[derive(Debug, PartialEq, Eq)]
pub struct ParseLevelError(());

impl fmt::Display for ParseLevelError {
    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
        fmt.write_str(LEVEL_PARSE_ERROR)
    }
}

// The Error trait is not available in libcore
#[cfg(feature = "std")]
impl error::Error for ParseLevelError {}

/// Returns a reference to the logger.
///
/// If a logger has not been set, a no-op implementation is returned.
pub fn logger() -> &'static dyn Log {
    // Acquire memory ordering guarantees that current thread would see any
    // memory writes that happened before store of the value
    // into `STATE` with memory ordering `Release` or stronger.
    //
    // Since the value `INITIALIZED` is written only after `LOGGER` was
    // initialized, observing it after `Acquire` load here makes both
    // write to the `LOGGER` static and initialization of the logger
    // internal state synchronized with current thread.
    if STATE.load(Ordering::Acquire) != INITIALIZED {
        static NOP: NopLogger = NopLogger;
        &NOP
    } else {
        unsafe { LOGGER }
    }
}

// WARNING: this is not part of the crate's public API and is subject to change at any time
#[doc(hidden)]
pub mod __private_api;

/// The statically resolved maximum log level.
///
/// See the crate level documentation for information on how to configure this.
///
/// This value is checked by the log macros, but not by the `Log`ger returned by
/// the [`logger`] function. Code that manually calls functions on that value
/// should compare the level against this value.
///
/// [`logger`]: fn.logger.html
pub const STATIC_MAX_LEVEL: LevelFilter = match cfg!(debug_assertions) {
    false if cfg!(feature = "release_max_level_off") => LevelFilter::Off,
    false if cfg!(feature = "release_max_level_error") => LevelFilter::Error,
    false if cfg!(feature = "release_max_level_warn") => LevelFilter::Warn,
    false if cfg!(feature = "release_max_level_info") => LevelFilter::Info,
    false if cfg!(feature = "release_max_level_debug") => LevelFilter::Debug,
    false if cfg!(feature = "release_max_level_trace") => LevelFilter::Trace,
    _ if cfg!(feature = "max_level_off") => LevelFilter::Off,
    _ if cfg!(feature = "max_level_error") => LevelFilter::Error,
    _ if cfg!(feature = "max_level_warn") => LevelFilter::Warn,
    _ if cfg!(feature = "max_level_info") => LevelFilter::Info,
    _ if cfg!(feature = "max_level_debug") => LevelFilter::Debug,
    _ => LevelFilter::Trace,
};

#[cfg(test)]
mod tests {
    use super::{Level, LevelFilter, ParseLevelError, STATIC_MAX_LEVEL};

    #[test]
    fn test_levelfilter_from_str() {
        let tests = [
            ("off", Ok(LevelFilter::Off)),
            ("error", Ok(LevelFilter::Error)),
            ("warn", Ok(LevelFilter::Warn)),
            ("info", Ok(LevelFilter::Info)),
            ("debug", Ok(LevelFilter::Debug)),
            ("trace", Ok(LevelFilter::Trace)),
            ("OFF", Ok(LevelFilter::Off)),
            ("ERROR", Ok(LevelFilter::Error)),
            ("WARN", Ok(LevelFilter::Warn)),
            ("INFO", Ok(LevelFilter::Info)),
            ("DEBUG", Ok(LevelFilter::Debug)),
            ("TRACE", Ok(LevelFilter::Trace)),
            ("asdf", Err(ParseLevelError(()))),
        ];
        for &(s, ref expected) in &tests {
            assert_eq!(expected, &s.parse());
        }
    }

    #[test]
    fn test_level_from_str() {
        let tests = [
            ("OFF", Err(ParseLevelError(()))),
            ("error", Ok(Level::Error)),
            ("warn", Ok(Level::Warn)),
            ("info", Ok(Level::Info)),
            ("debug", Ok(Level::Debug)),
            ("trace", Ok(Level::Trace)),
            ("ERROR", Ok(Level::Error)),
            ("WARN", Ok(Level::Warn)),
            ("INFO", Ok(Level::Info)),
            ("DEBUG", Ok(Level::Debug)),
            ("TRACE", Ok(Level::Trace)),
            ("asdf", Err(ParseLevelError(()))),
        ];
        for &(s, ref expected) in &tests {
            assert_eq!(expected, &s.parse());
        }
    }

    #[test]
    fn test_level_as_str() {
        let tests = &[
            (Level::Error, "ERROR"),
            (Level::Warn, "WARN"),
            (Level::Info, "INFO"),
            (Level::Debug, "DEBUG"),
            (Level::Trace, "TRACE"),
        ];
        for (input, expected) in tests {
            assert_eq!(*expected, input.as_str());
        }
    }

    #[test]
    fn test_level_show() {
        assert_eq!("INFO", Level::Info.to_string());
        assert_eq!("ERROR", Level::Error.to_string());
    }

    #[test]
    fn test_levelfilter_show() {
        assert_eq!("OFF", LevelFilter::Off.to_string());
        assert_eq!("ERROR", LevelFilter::Error.to_string());
    }

    #[test]
    fn test_cross_cmp() {
        assert!(Level::Debug > LevelFilter::Error);
        assert!(LevelFilter::Warn < Level::Trace);
        assert!(LevelFilter::Off < Level::Error);
    }

    #[test]
    fn test_cross_eq() {
        assert!(Level::Error == LevelFilter::Error);
        assert!(LevelFilter::Off != Level::Error);
        assert!(Level::Trace == LevelFilter::Trace);
    }

    #[test]
    fn test_to_level() {
        assert_eq!(Some(Level::Error), LevelFilter::Error.to_level());
        assert_eq!(None, LevelFilter::Off.to_level());
        assert_eq!(Some(Level::Debug), LevelFilter::Debug.to_level());
    }

    #[test]
    fn test_to_level_filter() {
        assert_eq!(LevelFilter::Error, Level::Error.to_level_filter());
        assert_eq!(LevelFilter::Trace, Level::Trace.to_level_filter());
    }

    #[test]
    fn test_level_filter_as_str() {
        let tests = &[
            (LevelFilter::Off, "OFF"),
            (LevelFilter::Error, "ERROR"),
            (LevelFilter::Warn, "WARN"),
            (LevelFilter::Info, "INFO"),
            (LevelFilter::Debug, "DEBUG"),
            (LevelFilter::Trace, "TRACE"),
        ];
        for (input, expected) in tests {
            assert_eq!(*expected, input.as_str());
        }
    }

    #[test]
    fn test_level_up() {
        let info = Level::Info;
        let up = info.increment_severity();
        assert_eq!(up, Level::Debug);

        let trace = Level::Trace;
        let up = trace.increment_severity();
        // trace is already highest level
        assert_eq!(up, trace);
    }

    #[test]
    fn test_level_filter_up() {
        let info = LevelFilter::Info;
        let up = info.increment_severity();
        assert_eq!(up, LevelFilter::Debug);

        let trace = LevelFilter::Trace;
        let up = trace.increment_severity();
        // trace is already highest level
        assert_eq!(up, trace);
    }

    #[test]
    fn test_level_down() {
        let info = Level::Info;
        let down = info.decrement_severity();
        assert_eq!(down, Level::Warn);

        let error = Level::Error;
        let down = error.decrement_severity();
        // error is already lowest level
        assert_eq!(down, error);
    }

    #[test]
    fn test_level_filter_down() {
        let info = LevelFilter::Info;
        let down = info.decrement_severity();
        assert_eq!(down, LevelFilter::Warn);

        let error = LevelFilter::Error;
        let down = error.decrement_severity();
        assert_eq!(down, LevelFilter::Off);
        // Off is already the lowest
        assert_eq!(down.decrement_severity(), down);
    }

    #[test]
    #[cfg_attr(not(debug_assertions), ignore)]
    fn test_static_max_level_debug() {
        if cfg!(feature = "max_level_off") {
            assert_eq!(STATIC_MAX_LEVEL, LevelFilter::Off);
        } else if cfg!(feature = "max_level_error") {
            assert_eq!(STATIC_MAX_LEVEL, LevelFilter::Error);
        } else if cfg!(feature = "max_level_warn") {
            assert_eq!(STATIC_MAX_LEVEL, LevelFilter::Warn);
        } else if cfg!(feature = "max_level_info") {
            assert_eq!(STATIC_MAX_LEVEL, LevelFilter::Info);
        } else if cfg!(feature = "max_level_debug") {
            assert_eq!(STATIC_MAX_LEVEL, LevelFilter::Debug);
        } else {
            assert_eq!(STATIC_MAX_LEVEL, LevelFilter::Trace);
        }
    }

    #[test]
    #[cfg_attr(debug_assertions, ignore)]
    fn test_static_max_level_release() {
        if cfg!(feature = "release_max_level_off") {
            assert_eq!(STATIC_MAX_LEVEL, LevelFilter::Off);
        } else if cfg!(feature = "release_max_level_error") {
            assert_eq!(STATIC_MAX_LEVEL, LevelFilter::Error);
        } else if cfg!(feature = "release_max_level_warn") {
            assert_eq!(STATIC_MAX_LEVEL, LevelFilter::Warn);
        } else if cfg!(feature = "release_max_level_info") {
            assert_eq!(STATIC_MAX_LEVEL, LevelFilter::Info);
        } else if cfg!(feature = "release_max_level_debug") {
            assert_eq!(STATIC_MAX_LEVEL, LevelFilter::Debug);
        } else if cfg!(feature = "release_max_level_trace") {
            assert_eq!(STATIC_MAX_LEVEL, LevelFilter::Trace);
        } else if cfg!(feature = "max_level_off") {
            assert_eq!(STATIC_MAX_LEVEL, LevelFilter::Off);
        } else if cfg!(feature = "max_level_error") {
            assert_eq!(STATIC_MAX_LEVEL, LevelFilter::Error);
        } else if cfg!(feature = "max_level_warn") {
            assert_eq!(STATIC_MAX_LEVEL, LevelFilter::Warn);
        } else if cfg!(feature = "max_level_info") {
            assert_eq!(STATIC_MAX_LEVEL, LevelFilter::Info);
        } else if cfg!(feature = "max_level_debug") {
            assert_eq!(STATIC_MAX_LEVEL, LevelFilter::Debug);
        } else {
            assert_eq!(STATIC_MAX_LEVEL, LevelFilter::Trace);
        }
    }

    #[test]
    #[cfg(feature = "std")]
    fn test_error_trait() {
        use super::SetLoggerError;
        let e = SetLoggerError(());
        assert_eq!(
            &e.to_string(),
            "attempted to set a logger after the logging system \
             was already initialized"
        );
    }

    #[test]
    fn test_metadata_builder() {
        use super::MetadataBuilder;
        let target = "myApp";
        let metadata_test = MetadataBuilder::new()
            .level(Level::Debug)
            .target(target)
            .build();
        assert_eq!(metadata_test.level(), Level::Debug);
        assert_eq!(metadata_test.target(), "myApp");
    }

    #[test]
    fn test_metadata_convenience_builder() {
        use super::Metadata;
        let target = "myApp";
        let metadata_test = Metadata::builder()
            .level(Level::Debug)
            .target(target)
            .build();
        assert_eq!(metadata_test.level(), Level::Debug);
        assert_eq!(metadata_test.target(), "myApp");
    }

    #[test]
    fn test_record_builder() {
        use super::{MetadataBuilder, RecordBuilder};
        let target = "myApp";
        let metadata = MetadataBuilder::new().target(target).build();
        let fmt_args = format_args!("hello");
        let record_test = RecordBuilder::new()
            .args(fmt_args)
            .metadata(metadata)
            .module_path(Some("foo"))
            .file(Some("bar"))
            .line(Some(30))
            .build();
        assert_eq!(record_test.metadata().target(), "myApp");
        assert_eq!(record_test.module_path(), Some("foo"));
        assert_eq!(record_test.file(), Some("bar"));
        assert_eq!(record_test.line(), Some(30));
    }

    #[test]
    fn test_record_convenience_builder() {
        use super::{Metadata, Record};
        let target = "myApp";
        let metadata = Metadata::builder().target(target).build();
        let fmt_args = format_args!("hello");
        let record_test = Record::builder()
            .args(fmt_args)
            .metadata(metadata)
            .module_path(Some("foo"))
            .file(Some("bar"))
            .line(Some(30))
            .build();
        assert_eq!(record_test.target(), "myApp");
        assert_eq!(record_test.module_path(), Some("foo"));
        assert_eq!(record_test.file(), Some("bar"));
        assert_eq!(record_test.line(), Some(30));
    }

    #[test]
    fn test_record_complete_builder() {
        use super::{Level, Record};
        let target = "myApp";
        let record_test = Record::builder()
            .module_path(Some("foo"))
            .file(Some("bar"))
            .line(Some(30))
            .target(target)
            .level(Level::Error)
            .build();
        assert_eq!(record_test.target(), "myApp");
        assert_eq!(record_test.level(), Level::Error);
        assert_eq!(record_test.module_path(), Some("foo"));
        assert_eq!(record_test.file(), Some("bar"));
        assert_eq!(record_test.line(), Some(30));
    }

    #[test]
    #[cfg(feature = "kv")]
    fn test_record_key_values_builder() {
        use super::Record;
        use crate::kv::{self, VisitSource};

        struct TestVisitSource {
            seen_pairs: usize,
        }

        impl<'kvs> VisitSource<'kvs> for TestVisitSource {
            fn visit_pair(
                &mut self,
                _: kv::Key<'kvs>,
                _: kv::Value<'kvs>,
            ) -> Result<(), kv::Error> {
                self.seen_pairs += 1;
                Ok(())
            }
        }

        let kvs: &[(&str, i32)] = &[("a", 1), ("b", 2)];
        let record_test = Record::builder().key_values(&kvs).build();

        let mut visitor = TestVisitSource { seen_pairs: 0 };

        record_test.key_values().visit(&mut visitor).unwrap();

        assert_eq!(2, visitor.seen_pairs);
    }

    #[test]
    #[cfg(feature = "kv")]
    fn test_record_key_values_get_coerce() {
        use super::Record;

        let kvs: &[(&str, &str)] = &[("a", "1"), ("b", "2")];
        let record = Record::builder().key_values(&kvs).build();

        assert_eq!(
            "2",
            record
                .key_values()
                .get("b".into())
                .expect("missing key")
                .to_borrowed_str()
                .expect("invalid value")
        );
    }

    // Test that the `impl Log for Foo` blocks work
    // This test mostly operates on a type level, so failures will be compile errors
    #[test]
    fn test_foreign_impl() {
        use super::Log;
        #[cfg(feature = "std")]
        use std::sync::Arc;

        fn assert_is_log<T: Log + ?Sized>() {}

        assert_is_log::<&dyn Log>();

        #[cfg(feature = "std")]
        assert_is_log::<Box<dyn Log>>();

        #[cfg(feature = "std")]
        assert_is_log::<Arc<dyn Log>>();

        // Assert these statements for all T: Log + ?Sized
        #[allow(unused)]
        fn forall<T: Log + ?Sized>() {
            #[cfg(feature = "std")]
            assert_is_log::<Box<T>>();

            assert_is_log::<&T>();

            #[cfg(feature = "std")]
            assert_is_log::<Arc<T>>();
        }
    }
}

מדפסת הזרקת דיו (באנגלית: Inkjet) היא מדפסת הפועלת בטכנולוגיית הדפסה המבוססת על סדרת מזרקים זעירים המתיזים טיפות דיו קטנות אל הנייר העובר מתחת לרצועה שבה הם נמצאים. ראש ה"מזריק דיו" כמעט צמוד לנייר בעת ההדפסה, כשראש הדיו נמצא במקום הנקבע על ידי המערכת הוא מתיז כמות מזערית של הדיו על הנייר ושואב את הדיו המיותר על מנת למנוע היווצרות כתמים. פעולה זו מתבצעת על ידי צינור מזערי שעוביו קטן יותר מעוביה של השערה האנושית.

השיטות העיקריות להזרקת הדיו
 החברות אפסון וברדר משתמשות בגביש פיזואלקטרי אשר משנה את צורתו בעת הזרמת זרם חשמלי ודוחף את טיפת הדיו לנייר. 
 שיטת הבועות: בתוך הצינור ישנו נגד קטן שפועל כגוף חימום, בעת הזרמת זרם חשמלי הוא מחמם את הדיו עד שטיפה מהדיו מתאדה. נפח אדי הדיו גדול מדיו נוזלי, וכך מאדי דיו מתנפחת בועה בתוך הצינור, הבועה דוחפת טיפה של דיו מחוץ לצינור, באמצעות אלפי פיפטות מזעריות האדים חוזרים למצב צבירה נוזלי וכתוצאה מהתכווצות הבועה טיפה מהדיו שנשפך חוזר פנימה ומונעת טפטוף.

מחיר מדפסת הזרקת דיו נמוך יחסית למדפסת לייזר.

קישורים חיצוניים

 מישל רוזנברג, על הזרקת דיו, באתר אימגו, 31 דצמבר 2012
 

ערכים שבהם תבנית בריטניקה אינה מתאימה
דיו

Το γράμμα ήτα (κεφαλαίο Η, πεζό η) είναι το έβδομο γράμμα του ελληνικού αλφαβήτου. Στο ευκλείδειο αλφάβητο κατείχε την όγδοη θέση.

Στο ελληνικό σύστημα αρίθμησης έχει αριθμητική αξία η´=8.

Προέλευση
Προέρχεται από το φοινικικό γράμμα χεθ  και σε ορισμένα τοπικά αλφάβητα της αρχαίας Ελλάδας διατήρησε και την μορφή αυτήν. Στα περισσότερα αλφάβητα συμβόλιζε τον δασύ ήχο του πνεύματος της δασείας και προφερόταν ως  (ēta). Στο ιωνικό αλφάβητο όμως, επειδή η ιωνική διάλεκτος απώλεσε τον αρχικό δασύ φθόγγο στις λέξεις («ψίλωση»), κατέληξε να προφέρεται ως  (ēta) και να συμβολίζει το μακρόχρονο φωνήεν [ē]. Όταν όμως καθιερώθηκε το ιωνικό αλφάβητο σε πολλές περιοχές της αρχαίας Ελλάδας, προέκυψε η ανάγκη να αποδίδεται με κάποιον τρόπο ο δασύς φθόγγος, μια και το ήτα ήταν πλέον [ē]. Έτσι κατέληξαν να χρησιμοποιούνται τα δύο μισά του Η, το μεν αριστερό ἧτα (├) ως δασύς φθόγγος, το δε δεξιό για να αποδώσει την έλλειψη δασύτητας ἦτα (┤). Τα πνεύματα δασεία ( ) και ψιλή () όπως τα ξέρουμε σήμερα προέκυψαν από το αριστερό και το δεξί μισό του Η αντίστοιχα.

Προφορά
Στη σύγχρονη προφορά ταυτίζεται με το ι. Η εξέλιξη αυτή στην προφορά πραγματοποιήθηκε κατά την περίοδο της κοινής ελληνικής και ονομάστηκε ιωτακισμός).

Το Η αντιστοιχεί στο λατινικό H h, όταν συμβολίζει τον ήχο της δασείας (π.χ. Ελλάς → Hellas), αλλά στο E e (π.χ. Άρης → Ares) ή στο I i, όταν συμβολίζει φωνήεν (π.χ. Αθήνα → Athina).

Το Η συμβόλιζε σε ένα αρχαιότερο ελληνικό σύστημα αρίθμησης, το ακροφωνικό σύστημα αρίθμησης, τον αριθμό 100, από το πρώτο γράμμα της λέξης  που γράφονταν ΗΕΚΑΤΟΝ → ἑκατόν (όπου το αρχικό Η αντικαταστάθηκε τελικά από το πνεύμα της δασείας).

Πηγές

Εξωτερικοί σύνδεσμοι 

η

गोवा या गोआ (कोंकणी: गोंय), क्षेत्रफल के अनुसार से भारत का सबसे छोटा और जनसंख्या के अनुसार चौथा सबसे छोटा राज्य है। पूरी दुनिया में गोवा अपने सुन्दर समुद्र के किनारों और प्रसिद्ध स्थापत्य के लिये जाना जाता है। गोवा पहले पुर्तगाल का एक उपनिवेश था। पुर्तगालियों ने गोवा पर लगभग 450 सालों तक शासन किया और 19 दिसंबर 1961 में यह भारतीय प्रशासन को सौंपा गया।

गोवा

नाम का उद्भव 
महाभारत में गोवा का उल्लेख गोपराष्ट्र यानि गोपालकों के देश के रूप में मिलता है। दक्षिण कोंकण क्षेत्र का उल्लेख गोवाराष्ट्र के रूप में पाया जाता है। संस्कृत के कुछ अन्य पुराने स्त्रोतों में गोवा को गोपकपुरी और गोपकपट्टन कहा गया है जिनका उल्लेख अन्य ग्रंथों के अलावा हरिवंशम और स्कंद पुराण में मिलता है। गोवा को बाद में कहीं कहीं गोअंचल भी कहा गया है। अन्य नामों में गोवे, गोवापुरी, गोपकापाटन औरगोमंत प्रमुख हैं। टोलेमी ने गोवा का उल्लेख वर्ष 200 के आस-पास गोउबा के रूप में किया है। अरब के मध्युगीन यात्रियों ने इस क्षेत्र को चंद्रपुर और चंदौर के नाम से इंगित किया है जो मुख्य रूप से एक तटीय शहर था। जिस स्थान का नाम पुर्तगाल के यात्रियों ने गोवा रखा वह आज का छोटा सा समुद्र तटीय शहर गोअ-वेल्हा है। बाद में उस पूरे क्षेत्र को गोवा कहा जाने लगा जिस पर पुर्तगालियों ने कब्जा किया।

जनश्रुति के अनुसार गोवा जिसमें कोंकण क्षेत्र भी शामिल है (और जिसका विस्तार गुजरात से केरल तक बताया जाता है) की रचना भगवान परशुराम ने की थी। कहा जाता है कि परशुराम ने एक यज्ञ के दौरान अपने बाणो की वर्षा से समुद्र को कई स्थानों पर पीछे धकेल दिया था और लोगों का कहना है कि इसी वजह से आज भी गोवा में बहुत से स्थानों का नाम वाणावली, वाणस्थली इत्यादि हैं। उत्तरी गोवा में हरमल के पास आज भूरे रंग के एक पर्वत को परशुराम के यज्ञ करने का स्थान माना जाता है।

इतिहास 

गोवा के लंबे इतिहास की शुरुआत् तीसरी सदी इसा पूर्व से शुरू होता है जब यहाँ मौर्य वंश के शासन की स्थापना हुई थी। बाद में पहली सदी के शुरुआत में इस पर कोल्हापुर के सातवाहन वंश के शासकों का अधिकार स्थापित हुआ और फिर बादामी के चालुक्य शासकों ने इस पर वर्ष 580 से 750 तक राज किया। इसके बाद के सालों में इस पर कई अलग अलग शासकों ने अधिकार किया। वर्ष 1312 में गोवा पहली बार दिल्ली सल्तनत के अधीन हुआ लेकिन उन्हें विजयनगर के शासक हरिहर प्रथम द्वार वहाँ से खदेड़ दिया गया। अगले सौ सालों तक विजयनगर के शासकों ने यहाँ शासन किया और 1469 में गुलबर्ग के बहामी सुल्तान द्वारा फिर से दिल्ली सल्तनत का हिस्सा बनाया गया। बहामी शासकों के पतन के बाद बीजापुर के आदिल शाह का यहाँ कब्जा हुआ जिसने गोअ-वेल्हा को अपनी दूसरी राजधानी बनाया।

1510 में, पुर्तगालियों ने एक स्थानीय सहयोगी, तिमैया की मदद से सत्तारूढ़ बीजापुर सुल्तान यूसुफ आदिल शाह को पराजित किया। उन्होंने वेल्हा गोवा में एक स्थायी राज्य की स्थापना की। यह गोवा में पुर्तगाली शासन का प्रारंभ था जो अगली साढ़े चार सदियों तक चला।

1843 में पुर्तगाली राजधानी को वेल्हा गोवा से पंजिम ले गए। मध्य 18 वीं शताब्दी तक, पुर्तगाली गोवा का वर्तमान राज्य सीमा के अधिकांश भाग तक विस्तार किया गया था।

भारत ने 1947 में अंग्रेजों से स्वतंत्रता प्राप्त की, भारत ने अनुरोध किया कि भारतीय उपमहाद्वीप में पुर्तगाली प्रदेशों को भारत को सौंप दिया जाए।किंतु पुर्तगाल ने अपने भारतीय परिक्षेत्रों की संप्रभुता पर बातचीत करना अस्वीकार कर दिया। पर 19 दिसंबर 1961 को, भारतीय सेना ने गोवा, दमन, दीव के भारतीय संघ में विलय के लिए ऑपरेशन विजय के साथ सैन्य संचालन किया और इसके परिणामस्वरूप गोवा, दमन और दीवभारत का एक केन्द्र प्रशासित क्षेत्र बना। 30 मई 1987 में केंद्र शासित प्रदेश को विभाजित किया गया था, और गोवा भारत का पच्चीसवां राज्य बनाया गया। जबकि दमन और दीव केंद्र शासित प्रदेश ही रहे।

भूगोल 
गोवा का क्षेत्रफल 3702 वर्ग किलोमीटर है। गोवा का अक्षांश और देशान्तर क्रमश: 14°53'54" और 73°40'33" E है। गोवा का समुद्र तट 132 किलोमीटर लम्बा है।
गोआ भारत का सबसे छोटा राज्य है।

अर्थ जगत 
गोवा का प्रमुख उद्योग पर्यटन है। पर्यटन के आलावा गोवा में लौह खनिज भी विपुल मात्रा में पाया जाता है जो जापान तथा चीन जैसे देशों में निर्यात होता है। गोवा मतस्य (मछली) उद्योग के लिए भी जाना जाता है लेकिन यहाँ की मछली निर्यात नहीं की जाती बल्कि स्थानीय बाजारों में बेची जाती है। यहाँ का काजू सउदी अरब, ब्रिटेन तथा अन्य यूरोपीय राष्ट्रों को निर्यात होता है। पर्यटन के वज़ह से बाकी उद्योग जो पर्यटन पर निर्भर करते है वो भी यहाँ पर जोर शोर से चालू हैं। गोवा में अभी तक सिर्फ़ एक ही विमानपत्तन है और दूसरा अभी बनने वाला है।

लोग और संस्कृति 
गोवा करीब करीब 450 साल तक पुर्तगाली शासन के अधीन रहा, इस कारण यहाँ यूरोपीय संस्कृति का प्रभाव बहुत महसूस होता है। गोवा की लगभग 60% जनसंख्या हिंदू और लगभग 28% जनसंख्या ईसाई है। गोवा की एक खास बात यह है कि, यहाँ के ईसाई समाज में भी हिंदुओं जैसी जाति व्यवस्था पाई जाती है।

गोवा के दक्षिण भाग में ईसाई समाज का ज्यादा प्रभाव है लेकिन वहाँ के वास्तुशास्त्र में हिंदू प्रभाव दिखाई देता है। सबसे प्राचीन मन्दिर गोवा में दिखाई देते है। उत्तर गोवा में ईसाइ कम संख्या में हैं इसलिए वहाँ पुर्तगाली वास्तुकला के नमूने ज्यादा दिखाई देते है।

संस्कृति की दृष्टि से गोवा की संस्कृति काफी प्राचीन है। 1000 साल पहले कहा जाता है कि गोवा "कोंकण काशी" के नाम से जाना जाता था। हालाँकि पुर्तगाली लोगों ने यहाँ के संस्कृति का नामोनिशान मिटाने के लिए बहुत प्रयास किए लेकिन यहाँ की मूल संस्कृति इतनी शक्तिशाली थी की वह ऐसा नहीं कर पाए।

गोवा की भाषा कोंकणी और लिपि देवनागरी है। हिन्दी का भी अधिकाधिक उपयोग होता है।

यातायात

बाहरी 
 हवाई: डैबोलिम विमानक्षेत्र यहाँ का घरेलू हवाई अड्डा है जो देश के सभी प्रमुख शहरों से जुड़ा है। अभी हाल के वर्षों में गोवा के लिये पणजी हवाई अड्डे से अंतर्राष्ट्रीय उड़ाने भी शुरू हुई हैं।
 सड़क: गोवा मुम्बई, बंगलोर से काफी अच्छी तरह जुड़ा हुआ है, इन शह्रों से गोवा के लिये सीधी लक्जरी बसें चलती हैं। इसके अलावा अन्य नजदीक के शहर भी आप सड़क द्वारा यहाँ से जा सकते हैं।
 रेल: जबसे यहाँ कोंकण रेलवे की शुरुआत हुई है गोवा भारत के पूर्वी तटीय शहरों से जुड़ गया है। कोंकण रेलवे अपनी गति और अच्छी सेवा के लिये पूरे भारत में मशहूर है। इसके अलावा गोवा आने के लिये देश के किसी भी बड़े स्टेशन से आप वास्को द गामा के लिये सीधी रेलगाड़ी पकड़ सकते हैं।

आंतरिक 
 टैक्सी बिना मीटर और मीटर वाली टैक्सियाँ यहाँ पर्यटकों को एक स्थान से दूसरे स्थान ले जाने का सबसे लोकप्रिय साधन है। बिना मीटर वाली टैक्सियों में यात्री पहले से भाड़े के बारे में तय करते हैं।
 बस गोवा में ज्यादातर बसे प्राईवेट चालकों द्वारा चलाई जाती हैं। आम तौर पर बसों में काफी भीड़ होती है। गोवा सरकार द्वारा यहाँ कदम्ब बस सर्विस चलाई जाती है जिनमें धीरे चलनेवाली बसों से लेकर द्रुत सेवा की लंबी दूरी की बसें शामिल होती हैं।
  नाव

पर्यटन 

वर्षा ऋतु के आगमन के साथ ही प्रकृति गोवा को कुछ ऐसा ही अलग, लेकिन अदभुत स्वरूप प्रदान करती है। यह स्थान शांतिप्रिय पर्यटकों और प्रकृति प्रेमियों को बहुत भाता है। गोवा एक छोटा-सा राज्य है। यहां छोटे-बड़े लगभग 40 समुद्री तट है। इनमें से कुछ समुद्र तट अंर्तराष्ट्रीय स्तर के हैं। इसी कारण गोवा की विश्व पर्यटन मानचित्र के पटल पर अपनी एक अलग पहचान है।

गोवा में पर्यटकों की भीड़ सबसे अधिक गर्मियों के महीनें में होती है। जब यह भीड़ समाप्त हो जाती है तब यहां शुरू होता है ऐसे सैलानियों के आने का सिलसिला जो यहां मानसून का लुत्‍फ उठाना चाहते हैं।

गोवा के मनभावन बीच की लंबी कतार में पणजी से 16 किलोमीटर दूर कलंगुट बीच, उसके पास बागा बीच, पणजी बीच के निकट मीरामार बीच, जुआरी नदी के मुहाने पर दोनापाउला बीच स्थित है। वहीं इसकी दूसरी दिशा में कोलवा बीच ऐसे ही सागरतटों में से है जहां मानसून के वक्त पर्यटक जरूर आना चाहेंगे। यही नहीं, अगर मौसम साथ दे तो बागाटोर बीच, अंजुना बीच, सिंकेरियन बीच, पालोलेम बीच जैसे अन्य सुंदर सागर तट भी देखे जा सकते हैं। गोवा के पवित्र मंदिर जिनसे श्री कामाक्षी, सप्तकेटेश्‍वर, श्री शांतादुर्ग, महालसा नारायणी, परनेम का भगवती मंदिर और महालक्ष्मी आदि दर्शनीय है। गोवा में किराए पर बाइक.

मांडवी नदी 
पणजी गोवा की राजधानी है। यहां के आधुनिक बाजार भी पर्यटकों को आकर्षित करते हैं। मांडवी नदी के तट पर बसे इस शहर में शाम के समय सैलानी रिवर क्रूज का आनन्द लेने पहुंचते हैं। मांडवी पर तैरते क्रूज पर संगीत एवं नृत्य के कार्यक्रम में गोवा की संस्कृति की एक झलक देखने को मिलती है।

गोवा के जिले 
गोवा में दो जिले हैं -

 उत्तर गोवा जिला
 दक्षिण गोवा जिला

खेल 
गोवा में सबसे लोकप्रिय खेल फुटबाल है। यहाँ कई लोकप्रिय फुटबाल क्लब हैं। इसके अलावा गोवा के बहुत से खिलाड़ी हाकी में भी दिलचस्पी रखते हैं। गोवा में अनेक समुद्रतट हैं . उन्मे से कुछ हैं बागा समुद्रतट, कलांगुते समुद्रतट, कोला समुद्रतट, इतियादी।

सन्दर्भ

इन्हें भी देखें
गोवा का इतिहास
गोवा मुक्ति संग्राम

बाहरी कड़ियाँ 
 
 Government of Goa official website
 Information on accommodation in hotels and resorts in Goa
 

 
भारत में पर्यटन

version: "{build}-{branch}"

# If we ever get a backlog larger than clone_depth, builds will fail
# spuriously. I do not think we will ever get 20 deep commits deep though.
clone_depth: 20

# We want to build everything, except for branches that are explicitly
# for messing around with Github Actions.
branches:
  except:
    - /devel-gha.+/


# We need a more up to date pip because Python 2.7 is EOL soon
init:
  - set PATH=C:\Python35;C:\Python35\Scripts;%PATH%


install:
  - ps: if (($env:CONFIGURATION) -eq "Debug" -And ($env:coverage) -eq "1" ) { pip --disable-pip-version-check install codecov }
  # This removes our changes to PATH. Keep this step last!
  - ps: if (($env:CONFIGURATION) -eq "Debug" -And ($env:coverage) -eq "1" ) { .\tools\misc\installOpenCppCoverage.ps1 }


before_build:
  # We need to modify PATH again, because it was reset since the "init" step
  - set PATH=C:\Python35;C:\Python35\Scripts;%PATH%
  - set CXXFLAGS=%additional_flags%
  # If we are building examples/extra-tests, we need to regenerate the amalgamated files
  - cmd: if "%examples%"=="1" ( python .\tools\scripts\generateAmalgamatedFiles.py )
  # Indirection because appveyor doesn't handle multiline batch scripts properly
  # https://stackoverflow.com/questions/37627248/how-to-split-a-command-over-multiple-lines-in-appveyor-yml/37647169#37647169
  # https://help.appveyor.com/discussions/questions/3888-multi-line-cmd-or-powershell-warning-ignore
  - cmd: .\tools\misc\appveyorBuildConfigurationScript.bat


# build with MSBuild
build:
  project: Build\Catch2.sln             # path to Visual Studio solution or project
  parallel: true                        # enable MSBuild parallel builds
  verbosity: normal                     # MSBuild verbosity level {quiet|minimal|normal|detailed}

test_script:
  - set CTEST_OUTPUT_ON_FAILURE=1
  - cmd: .\tools\misc\appveyorTestRunScript.bat


# Sadly we cannot use the standard "dimensions" based approach towards
# specifying the different builds, as there is no way to add one-offs
# builds afterwards. This means that we will painfully specify each
# build explicitly.
environment:
  matrix:
    - FLAVOR: VS 2019 x64 Debug Coverage Examples
      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
      examples: 1
      coverage: 1
      platform: x64
      configuration: Debug

    - FLAVOR: VS 2019 x64 Debug WMain
      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
      wmain: 1
      additional_flags: "/D_UNICODE /DUNICODE"
      platform: x64
      configuration: Debug

    - FLAVOR: VS 2019 x64 Debug Latest Strict
      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
      additional_flags: "/permissive- /std:c++latest"
      platform: x64
      configuration: Debug

    - FLAVOR: VS 2017 x64 Debug
      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
      platform: x64
      configuration: Debug

    - FLAVOR: VS 2017 x64 Release Coverage
      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
      coverage: 1
      platform: x64
      configuration: Debug

[package]

name = "log"
version = "0.4.33" # remember to update html_root_url
authors = ["The Rust Project Developers"]
license = "MIT OR Apache-2.0"
readme = "README.md"
repository = "https://github.com/rust-lang/log"
documentation = "https://docs.rs/log"
description = """
A lightweight logging facade for Rust
"""
categories = ["development-tools::debugging"]
keywords = ["logging"]
exclude = ["rfcs/**/*"]
rust-version = "1.71.0"
edition = "2021"

[package.metadata.docs.rs]
features = ["std", "serde", "kv_std", "kv_sval", "kv_serde"]

[features]
max_level_off   = []
max_level_error = []
max_level_warn  = []
max_level_info  = []
max_level_debug = []
max_level_trace = []

release_max_level_off   = []
release_max_level_error = []
release_max_level_warn  = []
release_max_level_info  = []
release_max_level_debug = []
release_max_level_trace = []

std = []

kv = []
kv_sval = ["kv", "value-bag/sval", "sval", "sval_ref"]
kv_std = ["std", "kv", "value-bag/error"]
kv_serde = ["kv_std", "value-bag/serde", "serde"]

# This is here to not break backwards compatibility with the implicit feature
# that enables support for serde based on the dependency name. Since we're now
# using serde_core, the implicit feature was renamed, this adds back an alias.
serde = ["serde_core"]

# Deprecated: use `kv_*` instead
# These `*_unstable` features will be removed in a future release
kv_unstable = ["kv", "value-bag"]
kv_unstable_sval = ["kv_sval", "kv_unstable"]
kv_unstable_std = ["kv_std", "kv_unstable"]
kv_unstable_serde = ["kv_serde", "kv_unstable_std"]

[dependencies]
serde_core = { version = "1.0", optional = true, default-features = false }
sval = { version = "2.16", optional = true, default-features = false }
sval_ref = { version = "2.16", optional = true, default-features = false }
value-bag = { version = "1.12", optional = true, default-features = false, features = ["inline-i128"] }

[dev-dependencies]
serde = { version = "1.0", features = ["derive"] }
serde_json = { version = "1.0" }
serde_test = { version = "1.0" }
sval = { version = "2.16" }
sval_derive = { version = "2.16" }
value-bag = { version = "1.12", features = ["test"] }

# NOTE: log doesn't actually depend on this crate. However, our dependencies,
# serde and sval, dependent on version 1.0 of the crate, which has problem fixed
# in 1.0.60, specifically in the following commit
# https://github.com/dtolnay/proc-macro2/commit/e31d61910049e097afdd3d27c37786309082bdcb.
# By defining the crate as direct dependency we can increase its minimal
# version making the minimal (crate) version CI happy.
proc-macro2 = { version = "1.0.63", default-features = false }

«Перестро́йка» — общее название, используемое для обозначения кардинальных перемен в экономической и политической структуре СССР, инициированных генеральным секретарём ЦК КПСС Михаилом Сергеевичем Горбачёвым в 1985—1991 годах. Началом перестройки считают 1987 год, когда на январском пленуме ЦК КПСС перестройка была объявлена новым государственным курсом. Перестройка в конечном счёте привела к распаду Советского союзного государства и фактически превращению Страны Советов из единого государства в исторический регион в Восточной Европе, Средней и Центральной Азии, Дальнем Востоке и Сибири с 15 международно признанными и несколькими непризнанными государствами, завершила и переосмыслила советскую эпоху и дала начало новой, постсоветской, современной эпохе с её либеральными реформами, частной собственностью, свободным рынком, правами человека, упрощённым визовым режимом, возвратом в некоторых местах к досоветскому, традиционному строю (обществу), пересмотру отношений со странами Востока и Запада, а также США, возрождению религиозной жизни и общин на местах и т. д.

Целью реформ была заявлена всесторонняя демократизация сложившегося в СССР общественно-политического и экономического строя, то есть иными словами переход к «народовластию» (досл. перевод понятия demokratia) на местах в самом широком смысле этого понятия. Планы экономических реформ разрабатывались ещё в 1983—1984 годах по поручению генерального секретаря ЦК КПСС Юрия Владимировича Андропова.

Впервые необходимость совершенствования существовавшей экономической системы — так называемого Ускорения — была провозглашена М. С. Горбачёвым на пленуме ЦК КПСС 23 апреля 1985 года. Однако эти меры касались только экономики, носили в основном административный характер и не затрагивали существа «развитого социализма». Кардинальная же реформа всей системы, включая политические изменения, началась после пленума ЦК КПСС 27 января 1987 года. Перестройка была обозначена в качестве задачи и как необходимое «преодоление эпохи застоя и обновление всех сторон жизни страны».

Важную роль в разработке идей перестройки играли видные учёные-обществоведы: Александр Николаевич Яковлев (ИМЭМО), Станислав Сергеевич Шаталин (ЦЭМИ), Татьяна Ивановна Заславская (ВЦИОМ), Евгений Максимович Примаков (ИМЭМО), Леонид Иванович Абалкин (Институт экономики АН СССР).

Оценки результатов перестройки в обществе разнятся. Цели реформ были достигнуты лишь частично: произошла демократизация общества, внедрена гласность, отменена цензура, достигнута разрядка в отношениях с Западом. В то же время в экономике СССР наступил спад, а с политической точки зрения итогами перестройки стали межэтнические конфликты, вооружённая борьба за власть и распад Советского Союза.

Термин 

15—17 мая 1985 года состоялась поездка генерального секретаря ЦК КПСС Горбачёва в Ленинград, где на встрече с активом Ленинградского горкома партии он впервые упомянул о необходимости перестройки общественно-политической жизни:

Слово было подхвачено СМИ и стало лозунгом начавшейся в СССР новой эпохи.

8 апреля 1986 года во время визита в Тольятти М. С. Горбачёв впервые употребил слово «перестройка», обозначив им политические и экономические перемены.

Историк Виктор Петрович Данилов отмечает, что «на языке того времени это понятие отнюдь не означало коренного изменения социально-экономических форм и сводилось к реорганизации некоторых хозяйственных функций и связей».

Этапы перестройки

Первый этап (март 1985 — январь 1987) 

11 марта 1985 года к власти в СССР пришёл Михаил Сергеевич Горбачёв, а уже 23 апреля на состоявшемся пленуме ЦК КПСС он заявил о необходимости реформирования системы под лозунгом «ускорения социально-экономического развития страны», то есть ускорения продвижения по социалистическому пути на основе эффективного использования достижений научно-технического прогресса, активизации человеческого фактора и изменения порядка планирования. Главной задачей стала интенсификация экономики и ускорение научно-технического прогресса. Ещё не шла речь о гласности, демократизации, социалистическом рынке и прочих вещах, которые позднее прочно войдут в обиход горбачёвской эпохи. В мае широко транслировавшаяся ленинградская речь Горбачёва взбудоражила жителей страны, и именно с этой речью у них стала ассоциироваться перестройка, хотя термин «перестройка» как лозунг в этот период не использовался и идеологического значения не имел; признавались отдельные недостатки существовавшей социально-экономической системы СССР и предпринимались попытки исправить их несколькими крупными кампаниями административного характера: ускорение развития народного хозяйства, автоматизация и компьютеризация, антиалкогольная кампания, «борьба с нетрудовыми доходами», введение Госприёмки за контролем производственного сектора, демонстрация борьбы с коррупцией.

Каких-либо радикальных шагов в этот период не предпринималось, внешне практически всё оставалось по-старому. В то же время в 1985—1986 годах была произведена замена основной массы старых кадров брежневского призыва на новую команду управленцев. Именно тогда в руководство страны были введены Александр Николаевич Яковлев, Егор Кузьмич Лигачёв, Николай Иванович Рыжков, Борис Николаевич Ельцин, Анатолий Иванович Лукьянов, Владимир Иванович Долгих и другие активные участники будущих событий. Николай Рыжков вспоминал (в газете «Новый Взгляд», 1992): «В ноябре 82-го года меня — совершенно неожиданно — избрали секретарём ЦК, и Андропов ввёл меня в команду, готовившую реформы. Туда входили и Горбачёв, Долгих… Мы стали разбираться с экономикой, а с этого началась перестройка в 85-м году, где практически были использованы итоги того, что сделали в 1983—1984-х годах. Не пошли бы на это — было бы ещё хуже».

Состоявшийся в феврале — марте 1986 года XXVII съезд КПСС изменил программу партии: провозглашался курс на «совершенствование социализма» (а не «построение коммунизма», как ранее); предполагалось к 2000 году удвоить экономический потенциал СССР и предоставить каждой семье отдельную квартиру (программа «Жильё—2000»).

Внешняя политика СССР в 1985—1986 годах продолжала оставаться достаточно жёсткой, несмотря на наметившееся сразу после прихода к власти Горбачёва небольшое потепление в отношениях с США и Западом. Существенный сдвиг на международной арене произошёл только осенью 1987 года, когда СССР согласился пойти на серьёзные уступки при подготовке соглашения об РСМД.

Второй этап (январь 1987 — июнь 1989) 
К концу 1986 — началу 1987 годов горбачёвская команда пришла к выводу, что административными мерами ситуацию в стране не изменить и предприняла попытку реформирования системы в духе демократического социализма. Этому шагу способствовали два удара по советской экономике в 1986 году: резкое падение цен на нефть и Чернобыльская катастрофа.

Новый этап начался с январского пленума ЦК КПСС 1987 года, на котором была выдвинута задача коренной перестройки управления экономикой, и характеризовался он началом масштабных реформ во всех сферах жизни советского общества (хотя отдельные меры начали приниматься ещё в конце 1986 года, например, Закон «Об индивидуальной трудовой деятельности»):
 В общественной жизни провозглашается политика гласности — смягчение цензуры в СМИ и снятие запретов на обсуждение тем, которые раньше замалчивались (в первую очередь сталинские репрессии, а также секс вообще и проституция в частности, наркомания, бытовое насилие, подростковая жестокость и т. д.).
 
 В экономике узаконивается частное предпринимательство в форме кооперативов (хотя слова «предпринимательство» и «частная собственность» произносить вслух пока не осмеливаются, кооперативы вводятся как элемент рынка в существующую социалистическую модель), начинают активно создаваться совместные предприятия с зарубежными компаниями.
 В международной политике основной доктриной становится «Новое мышление» — курс в сторону отказа от классового подхода в дипломатии и улучшения отношений с Западом.

В октябре 1987 года Горбачёв заявил, что перестройка рассчитана на "16–20 лет"

Выдвигаются лозунги о необходимости избавить социализм от «деформаций», о возвращении к «ленинским нормам», «идеалам Октября» и «социализму с человеческим лицом» посредством демократизации всех сторон жизни общества, реформирования политических институтов. В этот период были опубликованы почти все запрещённые ранее произведения Василия Гроссмана, Андрея Платонова, Евгения Замятина, Михаила Булгакова, Бориса Пастернака; резонанс в обществе вызвали новые книги: романы Чингиза Айтматова «Плаха», Анатолия Рыбакова «Дети Арбата», Владимира Дудинцева «Белые одежды», сборник рассказов Татьяны Толстой «На золотом крыльце сидели…». Вновь встал вопрос о сталинских репрессиях и реабилитации их жертв. В сентябре 1987 г. была создана комиссия Политбюро ЦК КПСС по реабилитации, которую возглавил Александр Николаевич Яковлев. Открытие в конце 1987 года Оптиной пустыни и Толгского монастыря и относительно публичное празднование 1000-летия крещения Руси в 1988 году воспринимались как знаки перемен в политике государства в отношении церкви.

Часть населения (в основном молодёжь и либеральная интеллигенция — «шестидесятники», заставшие предыдущую, хрущёвскую либерализацию) охвачена эйфорией от начавшихся после двух десятилетий застоя перемен и невиданной по прежним меркам свободы. Общественная апатия начала 80-х сменяется верой в светлое будущее.

Вместе с тем, с 1988 года в стране начинает постепенно нарастать общая неустойчивость: ухудшается экономическое положение, появляются сепаратистские настроения на национальных окраинах, вспыхивают первые межнациональные столкновения (Карабах).

Третий этап (июнь 1989 — сентябрь 1991) 
Заключительный этап, в этот период происходит резкая дестабилизация обстановки в стране. После I Съезда народных депутатов начинается противостояние коммунистической партии с возникшими в итоге демократизации общества новыми политическими группировками. Изначально начатые по инициативе сверху, во второй половине 1989 года перемены выходят из-под контроля властей. Трудности в экономике перерастают в полномасштабный кризис: в 1989 году экономический рост резко замедляется, в 1990-м сменяется падением, а к концу 1991-го страна оказывается на грани экономического коллапса. Происходит катастрофический обвал жизненного уровня населения: реальностью советского общества начала 90-х становятся массовая нищета и безработица. Достигает апогея хронический товарный дефицит: пустые полки магазинов становятся символом рубежа 1980—1990-х гг, с 1991 г. Европа активно помогает СССР в поставках гуманитарной помощи. Перестроечная эйфория в обществе сменяется разочарованием, неуверенностью в завтрашнем дне и массовыми антикоммунистическими настроениями. Усиливается эмиграция за рубеж. С 1990 года основной идеей становится уже не «совершенствование социализма», а построение демократии западного образца и рыночной экономики капиталистического типа.

В 1987—1991 гг. социально-экономический строй СССР начинает приобретать черты капитализма: легализуется частная собственность, образуются фондовый и валютный рынки, кооперация, СП и ИТД (индивидуально-трудовые доходы) начинают принимать форму бизнеса западного типа. «Новое мышление», половинчатые реформы, и политика ускорения (1985—1987) на международной арене сводится к односторонним уступкам Западу, в итоге чего СССР утрачивает многие свои позиции и фактически перестаёт быть сверхдержавой, ещё несколько лет назад контролировавшей половину мира. В РСФСР c июня 1988 года после 19-й партконференции КПСС и других республиках Союза к власти приходят сепаратистски настроенные силы — начинается «парад суверенитетов» — провозглашается независимость республик. Середина 80-начало 90-х гг. в политике ознаменовалось кровавыми боестолкновениями:
Декабрь 1986 г. — Алма-Ата (Казахстан);
Декабрь 1987 — февраль 1988 г. — Карабах (Армения и Азербайджан);
Апрель 1989 г. — Тбилиси (Грузия);
Январь 1990 г. — Баку (Азербайджан);
Январь 1991 г. — Рига (Латвия), Вильнюс (Литва).

17 марта 1991 г. в проведённом общесоюзном референдуме за сохранение единства СССР высказалось около 77 %, в нём участвовало 9 из 15 республик державы, в апреле — новый акт Союзного Договора перенесли на 20 августа. За сутки до подписания акта в Москву были введены войска — начался 3-дневный августовский путч 1991 г, после которого уже не было ни малейшего шанса на спасение СССР.
1 декабря 1991 года Украина заявила о своей независимости. 7-8 декабря в резиденции Вискули (Минск) лидеры РСФСР, Украины и Белоруссии подписали Беловежскую Декларацию о создании СНГ, вступившую в силу после Алма-Атинских переговоров (21.12.1991), куда вошли все 11 республик бывшего СССР.
Итогом такого развития событий стали ликвидация власти КПСС, Августовский кризис 1991 года и распад Советского Союза в августе — декабре 1991 года.

Четвёртый этап — окончание перестройки или пост-Перестройка (сентябрь — декабрь 1991 г.) 

Период между провалом ГКЧП и юридическим оформлением распада СССР к Перестройке обычно относить не принято; это своего рода «безвременье», когда, с одной стороны, единое государство формально ещё продолжало существовать, а с другой — советская история подошла к своему завершению и окончательная ликвидация СССР стала лишь вопросом времени. В этот период происходит демонтаж коммунистического строя и всей системы государственной власти в Советском Союзе. К концу 1991 года происходит фактический коллапс союзной экономики. Республики Прибалтики де-юре выходят из состава СССР, остальные республики также берут курс на независимость. Деятельность КПСС сначала приостанавливается, а затем окончательно запрещается. Вместо полноценных органов власти создаются суррогатные неконституционные структуры (Госсовет, КОУНХ, МЭК). Вся полнота реальной власти переходит с союзного на республиканский уровень. Работа над новым союзным договором продолжается до ноября, однако чем дальше, тем очевиднее становится стремление республиканских элит, почувствовавших вкус реальной власти, к окончательному размежеванию и обособлению. 8 декабря в резиденции «Вискули» в Беловежской пуще лидеры России, Украины и Белоруссии провозглашают, что Советского Союза больше нет. Центральная власть во главе с Горбачёвым парализована и уже ничего не может противопоставить этим действиям. 25 декабря 1991 года Михаил Горбачёв слагает с себя полномочия Президента Союза Советских Социалистических Республик, и 26 декабря 1991 года СССР перестаёт существовать.

Некоторые вехи

1985 год 

Наиболее ранней вехой в начале «Перестройки» является приход в марте 1985 года к власти М. С. Горбачёва, главного проводника преобразований в СССР.
 для широких масс населения Советского Союза перестройка началась с транслировавшейся широко по всей стране Ленинградской речи Горбачёва в мае 1985 года; именно эту речь можно считать началом перестройки
  — Постановление Совета министров СССР «О мерах по преодолению пьянства и искоренению самогоноварения».

1986 год 
  — Авария на Чернобыльской атомной электростанции.
  — Постановление Совета министров СССР «О мерах по усилению борьбы с нетрудовыми доходами».
 Сентябрь 1986 года — впервые президент Аргентины (Рауль Альфонсин) посетил СССР.
  — Верховный Совет СССР принял Закон СССР «Об индивидуальной трудовой деятельности».
 17—18 декабря — события в Алма-Ате

1987 год 
  — Первая несанкционированная демонстрация неправительственной и некоммунистической организации — общества «Память» в Москве.
  — Пленум ЦК КПСС рассмотрел вопрос «О задачах партии по коренной перестройке управления экономикой».
 
 Принят закон СССР «О государственном предприятии (объединении)».
 Принят «Закон о порядке обжалования в суд неправомерных действий должностных лиц, ущемляющих права гражданина»
 август 1987 года — Впервые разрешена безлимитная подписка на газеты и журналы.
 декабрь 1987 года — по решению Политбюро ЦК КПСС и Совета Министров СССР был создан Всесоюзный центр изучения общественного мнения (ВЦИОМ).

1988 год 
  — статья Нины Александровны Андреевой в газете «Советская Россия» — «Не могу поступаться принципами»
 Март 1988 года — впервые президент Уругвая (Хулио Мария Сангинетти) посетил СССР.
  — Принят закон «О кооперации в СССР».
 5—18 июня 1988 года — Всесоюзные торжественные мероприятия, приуроченные к 1000-летнему юбилею принятия христианства на Руси.
  —  — XIX Всесоюзная конференция КПСС, принявшая резолюции «О некоторых неотложных мерах по практическому осуществлению реформы политической системы страны», «О ходе реализации решений XXVII съезда КПСС и задачах по углублению перестройки», «О демократизации советского общества и реформе политической системы», «О борьбе с бюрократизмом», «О межнациональных отношениях», «О гласности», «О правовой реформе».
  — Указы Президиума ВС СССР «О порядке организации и проведения собраний, митингов, уличных шествий и демонстраций в СССР» и «Об обязанностях и правах внутренних войск МВД СССР при охране общественного порядка».
  — в Чимкенте (Казахская ССР) зарегистрирован первый в СССР кооперативный банк («Союз-банк»), его уставной капитал составил 1 млн рублей.
  — Начался суд над Юрием Михайловичем Чурбановым (5 сентября — 30 декабря).
  — На Пленуме ЦК КПСС проходит крупнейшая со сталинских времён «чистка» Политбюро.
 Октябрь 1988 года — впервые президент Бразилии (Жозе Сарней) посетил СССР.

1989 год 
 январь 1989 года — Началось первое свободное выдвижение кандидатов в народные депутаты СССР.
  — завершился вывод советских войск из Афганистана.
  — впервые советский хоккеист (Сергей Пряхин) официально принял участие в матче НХЛ.
  — разгон оппозиционного митинга у дома правительства ГССР в Тбилиси.
  —  — Визит главы СССР и КПСС М. Горбачёва в КНР. Начало процесса нормализации советско-китайских отношений.
  — Верховный Совет Литовской ССР принял декларацию о государственном суверенитете.
  —  — Первый съезд народных депутатов СССР.
  — Верховный Совет Латвийской ССР принял декларацию о государственном суверенитете.
  — Верховный Совет Эстонской ССР объявил незаконным присоединение республики к СССР в 1940 году.
 1989 год — Университеты и ВУЗы СССР начали готовить специалистов по специальности «социология».

1990 год 
 Январь 1990 года — армянские погромы в Баку; ввод советских войск в город Баку с целью подавления политической оппозиции, закончившееся гибелью более сотни жителей города, в основном азербайджанцев.
  — МИД Чехословакии потребовало вывести войска СССР с территории страны до конца 1990 года.
  — МИД Венгрии потребовало вывести войска СССР с территории страны до конца 1990 года.
  — На первых свободных выборах в Литве одержало победу движение «Саюдис».
  — Начало вывода советских войск из Чехословакии.
  — В итоге советско-монгольских переговоров принято решение о выводе советских войск из Монголии до 1992 года.
  — В результате выборов в Верховный Совет РСФСР избирательный блок «Демократическая Россия» получила около 20 % голосов избирателей.
  — Принят «Закон о собственности в СССР».
 Весна 1990 года — Эстония, Литва и Латвия, в одностороннем порядке, провозглашают независимость и объявляют о выходе из состава СССР. Начинается процесс распада государства на независимые республики.
  — На первых свободных выборах в ГДР одержало победу движение «Альянс за Германию».
  — На первых свободных выборах в Венгрии одержало победу движение «Венгерский демократический форум».
  — В результате переговоров сандинистского правительства Никарагуа и «контрас» подписано соглашение о немедленном прекращении огня.
  — Встреча министров иностранных дел Великобритании (Дуглас Хёрд), СССР (Эдуард Шеварднадзе), США (Джеймс Бейкер), Франции (Ролан Дюма), ГДР (Маркус Меккель) и ФРГ (Ганс-Дитрих Геншер) по проблеме объединения Германии.
  — Борис Николаевич Ельцин избран председателем Верховного Совета РСФСР.
  — СССР и США подписали соглашение об уничтожении и запрещении производства химического оружия и о подготовке многосторонней конвенции о запрещении химического оружия.
  — Первая встреча президента СССР Михаила Горбачёва и президента Южной Кореи Ро Дэ У, положившая начало процессу нормализации отношений между СССР и Южной Кореей.
  — На первых свободных выборах в Чехословакии одержало победу движение «Чешский гражданский форум».
  — съезд народных депутатов принимает Декларацию о государственном суверенитете России.
  — Принят «Закон о печати в СССР». Авторы: Михаил Александрович Федотов, Юрий Михайлович Батурин и Владимир Львович Энтин.
  — М. С. Горбачёв подписал президентский указ «О восстановлении прав всех жертв политических репрессий 20-50-х годов». Этим указом репрессии по политическим, социальным, национальным, религиозным и другим мотивам были признаны незаконными, а все права граждан, подвергшихся этим репрессиям, восстанавливались.
  — М. С. Горбачёв подписал президентский «Указ о возвращении советского гражданства лицам, его лишённым».
  — Принятие Закона СССР «О свободе совести и религиозных организациях».
  — Объединение Германии.
  — В Париже подписан договор об обычных вооружённых силах в Европе.
  — В Париже подписана Парижская хартия.

1991 год 
  — На референдуме в Литве по вопросу о независимости государства из 84,5 % имевших право голоса граждан за независимость высказались 90,5 %, против — 6,5 %.
  — На референдумах в Эстонии и Латвии по вопросу о независимости государства, в Эстонии из 82,68 % имевших право голоса граждан за независимость высказались 77,83 %, в Латвии из 87,57 % имевших право голоса граждан за независимость высказались 73,8 %.
  — Прошёл общесоюзный референдум о судьбе СССР. В России за сохранение союзного государства высказались 77 % участвовавших в голосовании, 26,4 % высказались против.
  — Верховный Совет Грузии принял Акт о восстановлении государственной независимости.
  — Завершился вывод советских войск из Чехословакии.
  — В Эфиопии войска Революционно-демократического фронта эфиопских народов заняли Аддис-Абебу.
  — В Лиссабоне президент Анголы Жозе Эдуарду душ Сантуш и лидер повстанческого движения УНИТА Жонаш Савимби подписали пакет соглашений о мирном урегулировании.
  — Выборы президента в РСФСР. Борис Николаевич Ельцин избран президентом. Он победил в первом туре с 57,3 % голосов.
  — Завершился вывод советских войск из Венгрии.
  —  — В Словении произошли вооружённые столкновения между югославской союзной армией и словенскими силами территориальной обороны.
  — Представители 9 государств — членов СЭВ подписали в Будапеште соглашение о роспуске организации.
  — На заседании Политического консультативного комитета ОВД в Праге 6 государств-членов приняли решение о роспуске организации.
  — В Москве в ходе визита президента США Джорджа Буша-старшего подписан советско-американский договор о сокращении и ограничении стратегических наступательных вооружений (СНВ-1).
  —  — Августовский путч. Ввод танков в Москву, штурм баррикад на Садовом кольце, 3 человека погибли. 22 августа вводится новый государственный флаг — Российский триколор в противовес советскому красному знамени с серпом и молотом.
  — Парламент Эстонии объявил о введении в действие Декларации независимости.
  — Парламент Латвии объявил о введении в действие Декларации независимости.
  — Верховный Совет Украины принял Декларацию независимости с условием её подтверждения на референдуме 1 декабря 1991 г.
  — Верховный Совет Беларуси принял Декларацию независимости.
  — Парламент Молдовы принял Декларацию независимости.
  — Верховный Совет Азербайджана принял решение о восстановлении государственной независимости на основе Акта 1918 г.
  — Верховный Совет Кыргызстана принял Декларацию независимости.
  — Верховный Совет Узбекистана принял Декларацию независимости.
  — Государственный Совет СССР признал независимость Литвы, Латвии и Эстонии.
  — В югославской Республике Македонии в ходе референдума большинство голосовавших высказались за независимость.
  — Верховный Совет Таджикистана принял Декларацию независимости.
  — Литва, Латвия и Эстония приняты в СБСЕ.
  — Литва, Латвия, Эстония, КНДР, Республика Корея, Микронезия и Маршалловы острова стали членам ООН.
  — Верховный Совет Армении принял Деклара

は、無生物と区別される属性、つまり「生命」を備えているものの総称。そしてその「生命」とは、生物の本質的属性として生命観によって抽象されるものであり、その定義はなかなか難しいものとなっている。とも。

定義 

「生命現象を示すもの」というのが一応の定義であるが、これ以外の定義も存在し、統一は困難であるとされる。生物が持ち、無生物が持たない能力や特徴としては「自己増殖能力」「エネルギー変換能力」「自己と外界との明確な隔離」が挙げられ、これに「進化する能力」を加えることも多い。また、生物は外界とのやりとりを絶やすことのない開放系を取りながら、恒常性（ホメオスタシス）を維持する能力を持ち、常に変化する。生物はすべて細胞を基礎としており、細胞によって構成されていないウイルスなども寄生する細胞がなくては増殖できない。

動物・菌類・植物・原生生物・古細菌・細菌などの総称。多くの場合ウイルスを含めないが、立場によっては含めることもある。なお、『岩波生物学辞典』ではウイルスは生物であるか断言できないとしている
。

生物の分類 

現在生きている生物は少なくとも300万種、おそらくは1000万種に達するが、これらをその特徴に応じて大小の分類階級に所属させ、それによって生物を整理し秩序を与えることを分類という。分類階級のうち、次に掲げるものは必ず設置される（基本分類階級）。すなわち大きいほうから順に界、門、綱、目、科、属である。

歴史的に最も古くは生物は植物と動物からなるとした二界説（植物界、動物界）があり、その後の生物観の進展とともに、三界説、五界説、八界説などが登場した。一般によく知られる五界説ではモネラ界、原生生物界、植物界、菌界、動物界に分類する。しかし近年では分子系統学の成果を反映して、界よりさらに上位の枠組みとしてドメインが設けられており、細胞特性に従い生物全体を真核生物、細菌（バクテリア）、古細菌（アーキア）に分類する三ドメイン説が一般的になってきている。三ドメイン説においては、動物、植物、菌類、原生生物はすべて真核生物という単一のドメインに属する。一方、モネラ界は細菌および古細菌という2つの大きなドメインに分割される。見た目の大きさという点では、細菌および古細菌はすべて微生物であるため、真核生物と違って日常で目にすることはまずないが、生態の多様さという点では細菌および古細菌ドメインは真核生物よりはるかに大きい。

また近年では、真核生物が細菌および古細菌が融合して誕生したとする説が有力となりつつあり（参照: 真核生物#起源）、この場合、地球上には本来２つのドメイン（細菌と古細菌）しか存在しなかったことになる。ちなみに古細菌は、かつて細菌よりも起源が古い可能性が示唆されたため付けられた名前であるが、実際のところは、細菌と古細菌は両者とも同等に古い起源をもっている。

生物相互の関係 
上でも説明したが地球上には少なくとも300万種の生物が生きていると言われており、それらの多様な生物の間には複雑な関係が成立している。たとえば寄生、共生などという関係があり、また動物が植物を食べるという関係や、ある生物が天敵に捕食される、というかなり直接的な関係もあり、ほかにもある生物が花粉を媒介する、といった関係もある。

こうして生物どうしは互いに「他の生物にとっての環境」となっている。これを <<生物的環境>> という。ある地域に共存している生物種の間ではさまざまな関係が成立しており、どの生物種に関しても、<<生物的環境>>つまり他のさまざまな生物との関係を分析してやっとその生活が理解できるようになる。

この生物相互の関係は、地球環境が変化するとともに変化してきた。そして生物が地球の環境にも影響を与えている（生物が地球の環境の影響を受け、また地球の環境を変化させていることは次節で解説）。

生物と地球環境 
生物が現れる前は、二酸化炭素が多くを占める構成であったと推測されている。その温室効果によって地表の温度も高かった。

そんな状態だった地球上に、（諸説あるが）今から35～24億年前ころにシアノバクテリア（藍藻）が登場し、光合成を行うようになり、生み出した酸素を海水中へ放出しはじめ、地球上に大量の酸素が形成されるようになった。（地球における大量の酸素の出現は「大酸化イベント」という。開始した時期や活発化した時期に関しては諸説ある。「大酸化イベント」の記事にグラフも掲載。）　

生物が出現し、特に光合成による有機物の生成（炭素固定）とそれに伴う（分子状）酸素の放出、生物由来の石灰岩の生成がなされた結果、今のような酸素が多く含まれた窒素主体の大気組成となった（ただし、大気組成の変化は生物だけによるものではない。地球の大気#地球大気の「進化」も参照のこと）

また、酸素の多い大気になったことによって、オゾン層が形成され、生物にとって有害な宇宙線や紫外線の遮断がなされ、生物の陸上進出が可能になった。また、海水中の酸素が増えることによって、海水に溶け込んだ鉄が酸化鉄となって沈降し鉄鉱床を堆積させた。

2021年現在の地球の大気組成は、窒素が78%、酸素が21%、アルゴン0.93%、二酸化炭素が0.041%という構成になっている。

地球上の全ての生物の共通の祖先があり（原始生命体・共通祖先）、その子孫達が増殖し複製するにつれ遺伝子に様々な変異が生じることで進化がおきたとされている。結果、今日の生物多様性が生まれ、お互いの存在(他者)や地球環境に依存しながら、相互に複雑な関係で結ばれる生物圏を形成するにいたっている。ガイア理論（ガイア仮説）では、このような地球を「自己調節能力を持ったひとつの巨大な生命体」とみなした。

生物を成り立たせる生体物質 

水、タンパク質、脂質、多糖、核酸は生物の主要な構成成分である。生きているという状態は、無数の化学反応の総和であるという見方もできる。これら化学反応がおこる場を提供しているのが水である。生物は水の特殊な物性に多くの事を依存しており、極めて重要でかつ主要な構成成分である。どの生物でも、体の約70％は水であり、その他の物質が30％ほどを占める。

タンパク質は量の上で多数を占める生体高分子である。20種類のアミノ酸が通常100 - 1000個重合してタンパク質となる。あるものは細胞を支える骨格となり、あるものは生体内化学反応の触媒となる（酵素）。

必要なタンパク質を必要な場所で産生するための情報を記録する生体高分子が核酸である。この情報は遺伝によって次の世代に引き継がれる。

ロバート・フックがコルクを顕微鏡観察して見出した小さな区画に小部屋（cell＝細胞）と名付けたように、細胞とはある区画化された空間を指す。この区画をしているのが細胞膜であり、脂質がその主要な成分である。脂質はエネルギーとして効率が良く、また貯蔵するのによい物質でもある。

生物は区画された空間ではあるが、完全に外界から遮断されているわけではない。外部からエネルギーを取り入れ内部で消費し、化学反応で物質を作り出す。生物間でのエネルギーの流通に炭水化物（糖）は重要であり、主に植物が光合成によって生産している。

地球外生命体 
地球以外の天体に生物が発見された事例は記録されていない。しかし、地球のそれと同様の生物あるいは全く異なった性質の生物が地球以外の場所に存在する可能性は否定できない。太陽系内においても、火星には生命が存在する可能性が指摘されている。2018年7月には、イタリア国立宇宙物理学研究所などからなる国際天文学チームがマーズ・エクスプレスの観測データに基づき、「火星の南極の厚さ1.5kmの氷床の下に幅20kmにわたって水とみられる層が存在する」との論文を発表した。この地底湖は、液体の状態が維持されていると推測されている。研究チームは、「生命にとって厳しい環境ながら単細胞生物が生存している可能性がある」と述べている。

系外惑星としては、2007年に発見されたグリーゼ581cに生物が生存可能な環境の存在が期待されたことがある（その後の研究によるとこの天体はハビタブルゾーンの外にある）。2008年現在、太陽系外における地球型惑星の観測成果も少しずつあがってきている。

有機物以外を構成要素とする生物も想定される。このような仮想理論は「代わりの生化学」と呼ばれている。とくにケイ素は、炭素と同じ族に含まれ化学的性質も似ていることから、「代わりの生化学」のベースとして比較的頻繁に言及される（ケイ素生物）。

サイエンス・フィクションの世界では、ガス・電磁波から成る生物などが登場する。他に純粋知性、精神あるいは物質によらない意識が登場するが、現在のところ物質的な実体に依拠しない意識は確認されていない。また多くの宗教で霊と呼ばれる形態の生物の存在を想定している。

ギャラリー

脚注

注釈

出典

参考文献

関連項目 

 生物学、生物の分類
 無生物
 伝説の生物一覧
 Wikipedia:多数の言語版にあるが日本語版にない記事/生物

外部リンク 
 

地球史

Eventi

Africa 
 In Ifriquya c'è la dinastia degli Ziridi

Asia 
 Dinastia dei Ghaznavidi in Afghanistan

Medio Oriente 
 Inizio del periodo fatimida in Egitto (fine nel 1711). La capitale dei Fatimidi è spostata al Cairo. La città raggiunge i 500 000 abitanti tra il X e l'XI secolo.
 I Fatimidi annettono la Siria, occupano Damasco ma si scontrano alla riconquista bizantina di Giovanni I Zimisce e alle divisioni arabe.

Europa 
 Guerra russo-bizantina: l'esercito russo di Sviatoslav dopo avere combattuto i bulgari per conto dei Bizantini, devasta i dintorni di Costantinopoli nel 970. Poi assediano Edirne ma sono sconfitti da Barda Sclero durante la battaglia di Arcadiopoli. L'esercito è in seguito scacciato dai Balcani da un'operazione terrestre e fluviale di Giovanni I Zimisce, che annette la Bulgaria orientale (971)
 In seguito alle ambasciate di Liutprando di Cremona e alle negoziazioni di Pandulfo Testadiferro a Costantinopoli, il basileus Giovanni I Zimisce e l'imperatore Ottone I concludono la pace nel sud Italia. L'imperatore bizantino riconosce la dignità di Ottone, e il futuro Ottone II sposerà una principessa bizantina.
 Battaglia di Tourtour dei provenzali contro la fortezza di Frassineto, un rifugio sarracino.
 La Boemia è cristianizzata.

Scoperte, arte, economia 
 Il califfo fatimida fa costruire un osservatorio al Cairo dove lavora Ibn Yunus

Personaggi

Note

Altri progetti 

 08

Sa 
Ferdinand von Saar (1833–1906)
Umberto Saba (1883–1957)
Robert Sabatier (1923–2012)
Ernesto Sabato (1911–2011)
Rolf D. Sabel (* 1949)
Martin Sabrow (* 1954)
Mário de Sá-Carneiro (1890–1916)
Leopold von Sacher-Masoch (1836–1895)
Hans Sachs (1494–1576)
Nelly Sachs (1891–1970)
Jonathan Sacks (1948–2020)
Oliver Sacks (1933–2015)
Vita Sackville-West (1892–1962)
Donatien-Alphonse-François, Marquis de Sade (1740–1814)
Abu’Abdellah Mosharrefo’d–Din ben Mosleho’d–Din Sa’di (zwischen 1213 und 1219 – 1292)
Douglas Sadownick (* 1959)
Rüdiger Safranski (* 1945)
Carl Sagan (1934–1996)
Françoise Sagan (1935–2004)
Hans Sahl (1902–1993)
Marshall Sahlins (1930–2021)
Edward Said (1935–2003)
SAID (1947–2021)
Angela Saini (* 1980)
Assoto Saint (1957–1994)
Antoine de Saint-Exupéry (1900–1944)
At-Tayyib Salih (1929–2009)
J. D. Salinger (1919–2010)
James Sallis (* 1944)
Sally Salminen (1906–1976)
Ernst von Salomon (1902–1972)
Sallust (86–35 v. Chr.)
Felix Salten (1869–1945)
James Salter (1925–2015)
Gaston Salvatore (1941–2015), CL / D
R. A. Salvatore (* 1959)
Lydie Salvayre (* 1948), FR
Jewgenij Samjatin (1884–1937)
Jeffrey L. Sammons (1936–2021), US
José Luis Sampedro (1917–2013), ES
Clara Sánchez (* 1955), ES
Rafael Sánchez Ferlosio (1927–2019), ES
George Sand (1804–1876)
Margit Sandemo (1924–2018)
Gregor Sander (* 1968)
Maurice-Yves Sandoz (1892–1958), CH
Cícero Sandroni (* 1935), BR
Edoardo Sanguineti (1930–2010)
Eric San Juan (* 1973), US
José Saramago (1922–2010)
Stephan Sarek (* 1957), D
Ken Saro-Wiwa (1941–1995)
William Saroyan (1908–1981)
Nathalie Sarraute (1900–1999), FR
Joseba Sarrionandia (* 1958)
Andrew Sarris (1928–2012), US
Joachim Sartorius (* 1946)
Jean-Paul Sartre (1905–1980)
Saskia Sassen (* 1949)
Alfonso Sastre (1926–2021), E
John Saul (* 1942)
Annie Saumont (1927–2017)
Dan Savage (* 1964)
Jon Savage (* 1953)
Richard Henry Savage (1846–1903)
Walter Savage Landor (1775–1864)
Sam Savage (1940–2019)
Roberto Saviano (* 1979)
Alberto Savinio (1891–1952)
Dorothy L. Sayers (1893–1957)
Şara Sayın (1926–2017)
Steven Saylor (* 1956)

Sc 
Giorgio Scerbanenco (1911–1969)
Andrea Schacht (1956–2017)
Carlo Schäfer (1964–2015)
Rafik Schami (* 1946)
Sydney Schanberg (1934–2016)
Frieda Schanz (1859–1944)
Frank Schätzing (* 1957), D
Karl Herbert Scheer
Paul Scheerbart (1863–1915)
Leopold Schefer (1784–1862)
Joseph Victor von Scheffel (1826–1886)
Ursel Scheffler (* 1938), D
Wolfgang Scheffler (1929–2008), D
Susanne Scheibler
Jonathan Schell (1943–2014), US
Peter Schellenbaum (1939–2018), CH
Bernardin Schellenberger (* 1944), D
Caroline Schelling (1763–1809)
Friedrich Schelling (1775–1854)
Andreas Schendel (* 1971), D
Daniela Schenk (* 1964), CH
Johannes Schenk (1941–2006)
Joan Schenkar (* 1952), USA
Max von Schenkendorf (1783–1817)
Walter Schenker (1943–2018)
Karl Adolf Scherer (1929–2008)
Marie-Luise Scherer (1938–2022), D
René Schérer (1922–2023), FR
Ronald M. Schernikau (1960–1991), D
Manfred Scheuch (1929–2016), AT
Mario Scheuermann (1948–2015), D
Christian Scheuß (* 1966), D
Jakob van Schevichaven (1866–1935)
Taras Grigorjewitsch Schewtschenko (1814–1861)
Alfred Schickel (1933–2015)
Gotthard B. Schicker (1946–2017)
Claudia Beate Schill (1952–2022)
Friedrich Schiller (1759–1805)
Helmut Schiller (* 1938), D
Lawrence Schimel (* 1971), US
Jochen Schimmang (* 1948)
Annemarie Schimmel (1922–2003)
Roland Schimmelpfennig (* 1967)
Ferdinand von Schirach (* 1964)
Frank Schirrmacher (1959–2014)
Wolfgang Schivelbusch (1941–2023)
Peter Schjeldahl (1942–2022)
Johannes Schlaf (1862–1941)
Evelyn Schlag (* 1952)
Einar Schleef (1944–2001)
August Wilhelm Schlegel (1767–1845)
Dorothea von Schlegel (1763–1839)
Friedrich von Schlegel (1772–1829)
Johann Elias Schlegel (1719–1749)
Carl Ludwig Schleich (1859–1922)
Friedrich Schleiermacher (1768–1834)
Klaus Schlesinger (1937–2001)
Christoph Schlingensief (1960–2010), D
Bernhard Schlink (* 1944), D
Joachim Schlör (* 1960), D
Andreas Schlüter (* 1958)
Ann-Helena Schlüter
Herman Schmalenbach (1885–1950), D
Werner Schmalenbach (1920–2010), D/CH
Dagmar Isabell Schmidbauer (* 1962), D
Wolfgang Schmidbauer (* 1941), D
Alfred Schmidt (1931–2012), D
Arno Schmidt (1914–1979), D
Christian Schmidt (1980), D
Helmut Schmidt (1918–2015), D
Helwig Schmidt-Glintzer (* 1948), D
Kathrin Schmidt (* 1958), D
Rudolf Schmidt (1875–1943), D
Wendelin Schmidt-Dengler (1942–2008), AT
Gerhard Schmidtchen (1925–2022), D
Wieland Schmied (1929–2014), AT
Marion Schmitt (* 1959)
Philipp Schmitz (1935–2015)
Johann Gottfried Schnabel (1692–1744/1748)
Siegfried Schnabl (1927–2015), D
Friedrich Schnack (1888–1977)
Harald Schneider (* 1962)
Karla Schneider (* 1938), D
Peter Schneider (* 1940), D
Reinhold Schneider (1903–1958), D
Wolfgang Schneider (1938–2003), D
Robert Wolfgang Schnell (1916–1986), D
Helmut Schnelle (1932–2015), D
Arthur Schnitzler (1862–1931), AT
Wolfdietrich Schnurre (1920–1989), D
Axel Schock (* 1965), D
Wilfried F. Schoeller (1941–2020), D
Christel Schöllhammer (* 1938), D
Peter Schoenen (1952–2014), D
Sigmar Schollak (1930–2012), D
Peter Scholl-Latour (1924–2014), D/FR
Eike Schönfeld (* 1949), D
Dietmar Schönherr (1926–2014)
Johannes Schönherr (1894–1961)
Karl Schönherr (1867–1943)
Katja Schönherr (* 1982)
Renate Schoof (* 1950) D
Adele Schopenhauer (1797–1849)
Arthur Schopenhauer (1788–1860)
Roberto Schopflocher (1923–2016)
Eberhard Schorsch (1935–1991)
Carl E. Schorske (1915–2015), US
Claudia Schoppmann (* 1958), D
Justus Georg Schottelius (1612–1676)
Julie Schrader (1881–1939), D
Daniel Schreiber (* 1977), D
Hermann Schreiber (1920–2014)
Hermann Schreiber (1929–2020)
Jürgen Schreiber (1947–2022), D
Karl-Heinz Schreiber (1949–2014)
Klaus Peter Schreiner (1930–2017), D
Peter Schreiner (* 1953), D
Angelika Schrobsdorff (1927–2016)
Rudolf Alexander Schröder (1878–1962), D
Willy Schrödter (1878–1971)
Raoul Schrott (* 1964), AT
Jürg Schubiger (1936–2014), CH
Bernd Schuh (* 1948), D
Jean-Jacques Schuhl (* 1941), FR
Herbert Schui (1940–2016), D
Budd Schulberg (1914–2009), US
Herbert Schuldt (* 1941)
Horst Schüler-Springorum (1928–2015), D
Sarah Schulman (* 1958), US
Bruno Schulz (1892–1942), PL
Frank Schulz (* 1957), D
Franz Schulz (1897–1971), AT/US
Hagen Schulze (1943–2014), D
Micha Schulze (* 1967), D
Hans-Eugen Schulze (1922–2013), D
Ingo Schulze (* 1962), D
Dirk Schümer (* 1962), D
Romy Schurhammer (1936–2019), D
Maik T. Schurkus (* 1970), D
Wolfram Schütte (* 1939), D
Silke Schütze (* 1961), D
Stephan Schütze (1771–1839), D
James Schuyler (1923–1991), USA
Gustav Schwab (1792–1850), D
Werner Schwab (1958–1994), AT
Brigitte Schwaiger (1949–2010), AT
Marcel Schwander (1929–2010), CH
Delmore Schwartz (1913–1966), US
Lynne Sharon Schwartz (* 1939), US
Alice Schwarzer (* 1942), D
Alfred Otto Schwede (1915–1987), D
Michael Schweer
Albert Schweitzer (1875–1965), D / FR
Rolf Schwendter (1939–2013), AT
Hermann Schweppenhäuser (1928–2015), D
Malin Schwerdtfeger (* 1972), D
Ulrike Schwieren-Höger (* 1951), D
Peter Schwindt (* 1964), D
Monique Schwitter (* 1972), CH / D
Kurt Schwitters (1887–1948), D
Leonardo Sciascia (1921–1989), IT
C. R. Scott (* 1984), D
Gil Scott-Heron (1949–2011), US
Melissa Scott (* 1960), US
Michael Scott (* 1959), IRL
Sir Walter Scott (1771–1832)
Lisa Scottoline (* 1955), US
Joseph Medlicott Scriven (1820–1886)
Roger Scruton (1944–2020), GB
Madeleine de Scudéry (1607–1701)

Se 
Charles Sealsfield (1793–1864)
W. G. Sebald (1944–2001)
David Sedaris (* 1956)
Eve Kosofsky Sedgwick (1950–2009)
Annette Seemann (* 1959)
Peter Seewald (* 1954)
Giorgos Seferis (1900–1971)
Erich Segal (1937–2010)
Tom Segev (* 1945)
Anna Seghers (1900–1983)
Jan Seghers (* 1958)
Georg Seidel (1945–1990)
Heinrich Seidel (1842–1906)
Heinrich Wolfgang Seidel (1876–1945)
Ina Seidel (1885–1974)
Oskar Seidlin (1911–1984)
John Seigenthaler senior (1927–2014)
Lutz Seiler (* 1963), D
Susanne Seitz (* 1964)
Martin Selber (1924–2006)
Erich Selbmann (1926–2006)
Fritz Selbmann (1899–1975)
Dirk Seliger (* 1970)
Rafael Seligmann (* 1947)
Shyam Selvadurai (* 1965)
Friedrich Hermann Semmig (1820–1897)
Jeanne Berta Semmig (1867–1958)
Jaime Semprun (1947–2010)
Jorge Semprún (1923–2011)
Amartya Sen (* 1933)
Maurice Sendak (1928–2012)
Ramón J. Sender (1901–1982)
Nedim Şener (* 1966)
Richard Sennett (* 1943)
Zafer Şenocak (* 1961)
Luis Sepúlveda (1949–2020)
Lucius Annaeus Seneca (55 v. Chr. – 40 n. Chr.)
Seo Jeong-in (* 1936)
Seo Young-eun (* 1943)
Wolf Serno (* 1944)
Walter Serner (1889–1942)
Michel Serres (1930–2019)
Clemens J. Setz (* 1982)
Wolfram Setz (1941–2023)
Bernhard Setzwein (* 1960)
Johann Gottfried Seume (1763–1810)
Beppe Severgnini (* 1956)
Ruth Seydewitz (1905–1989)
Napoleon Seyfarth (1953–2000)
Joachim Seyppel (1919–2012)
Hilal Sezgin (* 1970)

Sg 
Manlio Sgalambro (1924–2014)

Sh 
Elif Shafak (* 1971)
Peter Shaffer (1926–2016)
William Shakespeare (1564–1616)
Meir Shalev (1948–2023)
Zeruya Shalev (* 1959)
Ralph Shallis († 1995)
Sidney Shapiro (1915–2014)
Tom Sharpe (1928–2013)
George Bernard Shaw (1856–1950)
Irwin Shaw (1913–1984)
Patricia Shaw (* 1929)
Robert Sheckley (1928–2005)
Maurice Sheehy (1928–1991)
Mary Wollstonecraft Shelley (1797–1851)
Percy Bysshe Shelley (1792–1822)
Lucius Shepard (1947–2014)
Richard Brinsley Sheridan (1751–1816)
Randy Shilts (1951–1994)
Shin Kyong-nim (* 1936)
Vladimir Shlapentokh (1926–2015)

Si 
Jules Siber (1871–1943)
Gertrud Siche-Tarnowski
Barbara Sichtermann (* 1943)
Enzo Siciliano (1934–2006)
Wolfram Siebeck (1928–2016)
Wolf Jobst Siedler (1926–2013)
Martin Siems (1948–2020)
Hans Siemsen (1891–1969)
Henryk Sienkiewicz (1846–1916)
Christian Sigrist (1935–2015)
Volkmar Sigusch (1940–2023)
Arthur Silbergleit (1881–1943)
Alan Sillitoe (1928–2010)
Ignazio Silone (1900–1978)
Charles Silverstein (1935–2023)
Clifford D. Simak (1904–1988)
Georges Simenon (1903–1989)
Charles Simic (1938–2023)
Georg Simmel (1858–1918)
Johannes Mario Simmel (1924–2009)
Claude Simon (1913–2005)
Erik Simon (* 1950)
Simonides von Amorgos (7. Jahrhundert v. Chr.)
Simonides von Keos (557 oder 556 – 468 oder 467 v. Chr.)
Konstantin Simonow (1915–1979)
N. F. Simpson (1919–2011)
Hüseyin Şimşek (* 1962)
Sin Kyong-suk (* 1963)
Upton Sinclair (1878–1968)
Isaac B. Singer (1904–1991)
Khushwant Singh (1915–2014)
Saut Situmorang (* 1966)
Sitor Situmorang (1924–2014)
Edith Sitwell (1887–1964)

Sj–So 
Arne Sjöberg Paul Brinkmann (1934–1997)
Maj Sjöwall (1935–2020)
Maya Skiba (* 1989)
Hamid Skif (1951–2011)
Scipio Slataper (1888–1915)
Henry Slesar (1927–2002)
Ondreij Sliacki (1849–1921)
Joshua Slocum (1844–1909)
Joan Slonczewski (* 1956)
Peter Sloterdijk (* 1947)
Clark Ashton Smith (1893–1961)
Cordwainer Smith Paul Linebarger (1913–1966)
Emma Smith (1923–2018)
Lillian Smith (1897–1966)
Martin Cruz Smith (* 1942)
Stevie Smith (1902–1971)
Wilbur Smith (1933–2021)
Ján Smrek (1898–1982)
Timothy Snyder (* 1969)
Dava Sobel (* 1947), US
Jehoschua Sobol (* 1939)
Ernst Solèr (1960–2008)
Philippe Sollers (1936–2023)
Franco Solo (Verlagspseudonym, verschiedene Autoren)
Alexander Solschenizyn (1918–2008)
Nicolaus Sombart (1923–2008)
Werner Sombart (1863–1941)
Volker Sommer (* 1954)
Hugo Sonnenschein (1889–1953)
Marco Sonnleitner (* 1965)
Susan Sontag (1933–2004)
Michael Sontheimer (* 1955)
Sophokles (497/96–≈406 v.a.Z.)
Osvaldo Soriano (1943–1997)
Flavio Soriga (* 1975)
Wladimir Sorokin (* 1955)
Dido Sotiriou (1909–2004)
Philippe Soupault (1897–1990)
Ivan Southall (1921–2008)
Johannes K. Soyener (1945–2018)
Jura Soyfer (1912–1939)
Wole Soyinka (* 1934)

Sp 
Tom Spanbauer (* 1946), US
Muriel Spark (1918–2006), GB
Nicholas Sparks (* 1965), US
Bernd Späth (* 1950), D
Gerold Späth (* 1939), CH
Stephen Spender (1909–1995), GB
Tilman Spengler (* 1947), D
Manès Sperber (1905–1984), AT
Martin Sperr (1944–2002), D
Monika Sperr (1941–1984), D
Dieter Spethmann (1926–2016), D
Art Spiegelman (* 1948), US
Erik Spiekermann (* 1947), D
Arndt Spieth (* 1962), D
Erica Spindler (* 1957), US
Jerry Spinelli (* 1941), US
Burkhard Spinnen (* 1956), D
Carl Spitteler (1845–1924), CH
Robert L. Spitzer (1932–2015), US
Heinrich Spoerl (1887–1955), D
C.M. Spoerri (* 1983), CH
Donald Spoto (1941–2023), US/DK
Hans-Hermann Sprado (1956–2014), D
Johanna Spyri (1827–1901), CH

St

Sta – Ste 
 Reiner Stach (* 1951), D
 Emerich von Stadion (1838–1901), AT
 Anne Louise Germaine de Staël (1766–1817)
 Helmut Stalder (* 1966), CH
 George Stambolian (1938–1991), US
 Peter Stamm (* 1963), CH
 Regula Stämpfli (* 1962), CH
 Henry Morton Stanley (1841–1904), GB
 Pietro Stanzano (1928–1968), IT
 Andrzej Stasiuk (* 1960), PL
 Joseph Staten, US
 Edward St Aubyn (* 1960), GB
 Toralf Staud (* 1972), D
 Robert Stauffer (* 1936), D
 Michael Stavarič (* 1972), AT
 John Stave (1929–1993), D
 Jerzy Stefan Stawiński (1921–2010), PL
 Bernhard Stecher (* 1961), A
 Danielle Steel (* 1947), US
 Verena Stefan (1947–2017), CH
 Jón Kalman Stefánsson (* 1963)
 Hansjakob Stehle (1927–2015), D
 Robert Steigerwald (1925–2016), D
 Gertrude Stein (1874–1946), US
 Peter Steinacker (1943–2015), D
 Thomas von Steinaecker (* 1977), D
 Peter Steinbach (Drehbuchautor) (1938–2019), D
 Peter Steinbach (Historiker) (* 1948), D
 John Steinbeck (1902–1968), US
 Guido Steinberg (* 1968), D
 Karl Steinbuch (1917–2005)
 George Steiner (1929–2020), US
 Jens Steiner (* 1975), CH
 Jörg Steiner (1930–2013), CH
 Andreas Steinhöfel (* 1962), D
 Klaus Steiniger (1932–2016), D
 Ronen Steinke (* 1983), D
 Marlene Stenten (1935–2019), D
 Neal Stephenson (* 1959), US
 Carola Stern (1925–2006), D
 Fritz Stern (1926–2016), US
 Horst Stern (1922–2019), D
 Carl Sternheim (1878–1942)
 Norbert Sternmut (* 1958)
 Andreas Sternweiler (* 1957), D
 Julius Stettenheim (1831–1916)
 Johann Kaspar Steube (1747–1795)
 Karl Steuerwald (1905–1989), D
 Wallace Stevens (1879–1955), US
 Robert Louis Stevenson (1850–1894)
 Samuel M. Steward (1909–1993), US
 Fred Mustard Stewart
 Mary Stewart (1916–2014), GB

Sti – Sty 
Vicki Stiefel, US
Caspar von Stieler (1632–1707)
Helm Stierlin (1926–2021), D
Adalbert Stifter (1805–1868), D
Klaus Stiller (* 1941), D
Michael Stiller (1945–2016), D
Julius Stinde (1841–1905), D
Conradine Stinde (1856–1925), D
Helene Stöcker (1869–1943), D
Juliana von Stockhausen (1899–1998), D
Charles Warren Stoddard (1843–1909), GB
Dejan Stojanović (* 1959), US, SR
Ceija Stojka (1933–2013), AT
Bram Stoker (1847–1912), GB
Clifford Stoll (* 1950), US
Michael Stolleis (1941–2021), D
Robert Stoller (1925–1991), US
Aryeh Lev Stollman (* 1954), US
Manfred Stolpe (1936–2019), D
Irving Stone (1903–1989), US
Hans Joachim Störig (1915–2012), D
Theodor Storm (1817–1888), D
Rex Stout (1886–1975), US
Horst Stowasser (1951–2009)
Lytton Strachey (1880–1932), GB
August Stramm (1874–1915), D
Giovanni Francisco Straparola (~1480–~1558)
Botho Strauß (* 1944), D
Emil Strauß (1866–1960), D
Leo Strauss (1899–1973)
Werner Streletz (* 1949), D
Carlo Strenger (1958–2019), CH/ISR
Jan Stressenreuter (1961–2018), D
Johan August Strindberg (1849–1912)
Erwin Strittmatter (1912–1994), D
Eva Strittmatter (1930–2011), D
Tina Stroheker (* 1948), D
Anna Stroka (1923–2020), PL
Gisbert Strotdrees (* 1960), D
Arkadi Strugazki, RUS
Boris Strugazki, RUS
Ulf G. Stuberger (1949–2015), D
Heinz Stübig (1939–2021), D
Benjamin von Stuckrad-Barre (* 1975), D
Giani Stuparich (1891–1961), IT
Howard O. Sturgis (1855–1920), GB
Jakob Stutz (1801–1871), SCHW
William Styron (1925–2006), US

Su–Sz 
Andreas Suchanek (* 1982)
Hermann Sudermann (1857–1928)
Eugène Sue (1804–1859)
Hannes Sulzenbacher (* 1968)
Alain Claude Sulzer (* 1953)
Ingo Sundmacher (* 1965)
Sung Suk-je (* 1960)
Wolfgang Suppan (1933–2015)
Peter Surava (1912–1995)
Manil Suri (* 1959)
Arno Surminski (* 1934)
Ida Sury (1911–2004), CH
Patrick Süskind (* 1949)
Ron Suresha (* 1958)
Paul Sussman (1968–2012)
Rosemary Sutcliff (1920–1992)
Martin Suter (* 1948)
Bertha von Suttner (1843–1914)
Italo Svevo (1861–1928)
Leonie Swann (* 1975)
Emanuel Swedenborg (1688–1772)
Matthew Sweeney (1952–2018)
Jonathan Swift (1667–1745)
Algernon Charles Swinburne (1837–1909)
John Addington Symonds (1840–1893)
Arthur William Symons (1865–1945)
Julian Symons (1912–1994)
John Millington Synge (1871–1909)
Michael Szameit (1950–2014)
Thomas Szasz (1920–2012)
Antal Szerb (1901–1945)

S

#!/usr/bin/env node
'use strict';

var _ = require('../lodash'),
    fs = require('fs'),
    path = require('path');

var args = (args = process.argv)
  .slice((args[0] === process.execPath || args[0] === 'node') ? 2 : 0);

var filePath = path.resolve(args[1]),
    reLine = /.*/gm;

var pattern = (function() {
  var result = args[0],
      delimiter = result.charAt(0),
      lastIndex = result.lastIndexOf(delimiter);

  return RegExp(result.slice(1, lastIndex), result.slice(lastIndex + 1));
}());

/*----------------------------------------------------------------------------*/

fs.writeFileSync(filePath, fs.readFileSync(filePath, 'utf8').replace(pattern, function(match) {
  var snippet = _.slice(arguments, -3, -2)[0];
  return match.replace(snippet, snippet.replace(reLine, ''));
}));

import pytest

import click.types

# Common (obj, expect) pairs used to construct multiple tests.
STRING_PARAM_TYPE = (click.STRING, {"param_type": "String", "name": "text"})
INT_PARAM_TYPE = (click.INT, {"param_type": "Int", "name": "integer"})
BOOL_PARAM_TYPE = (click.BOOL, {"param_type": "Bool", "name": "boolean"})
HELP_OPTION = (
    None,
    {
        "name": "_click_default_help",
        "param_type_name": "option",
        "opts": ["--help"],
        "secondary_opts": [],
        "type": BOOL_PARAM_TYPE[1],
        "required": False,
        "nargs": 1,
        "multiple": False,
        "default": False,
        "envvar": None,
        "help": "Show this message and exit.",
        "prompt": None,
        "is_flag": True,
        "flag_value": True,
        "count": False,
        "hidden": False,
    },
)
NAME_ARGUMENT = (
    click.Argument(["name"]),
    {
        "name": "name",
        "param_type_name": "argument",
        "opts": ["name"],
        "secondary_opts": [],
        "type": STRING_PARAM_TYPE[1],
        "required": True,
        "nargs": 1,
        "multiple": False,
        "default": None,
        "envvar": None,
        "help": None,
    },
)
NUMBER_OPTION = (
    click.Option(["-c", "--count", "number"], default=1),
    {
        "name": "number",
        "param_type_name": "option",
        "opts": ["-c", "--count"],
        "secondary_opts": [],
        "type": INT_PARAM_TYPE[1],
        "required": False,
        "nargs": 1,
        "multiple": False,
        "default": 1,
        "envvar": None,
        "help": None,
        "prompt": None,
        "is_flag": False,
        "flag_value": None,
        "count": False,
        "hidden": False,
    },
)
HELLO_COMMAND = (
    click.Command("hello", params=[NUMBER_OPTION[0]]),
    {
        "name": "hello",
        "params": [NUMBER_OPTION[1], HELP_OPTION[1]],
        "help": None,
        "epilog": None,
        "short_help": None,
        "hidden": False,
        "deprecated": False,
    },
)
HELLO_GROUP = (
    click.Group("cli", [HELLO_COMMAND[0]]),
    {
        "name": "cli",
        "params": [HELP_OPTION[1]],
        "help": None,
        "epilog": None,
        "short_help": None,
        "hidden": False,
        "deprecated": False,
        "commands": {"hello": HELLO_COMMAND[1]},
        "chain": False,
    },
)


@pytest.mark.parametrize(
    ("obj", "expect"),
    [
        pytest.param(
            click.types.FuncParamType(range),
            {"param_type": "Func", "name": "range", "func": range},
            id="Func ParamType",
        ),
        pytest.param(
            click.UNPROCESSED,
            {"param_type": "Unprocessed", "name": "text"},
            id="UNPROCESSED ParamType",
        ),
        pytest.param(*STRING_PARAM_TYPE, id="STRING ParamType"),
        pytest.param(
            click.Choice(("a", "b")),
            {
                "param_type": "Choice",
                "name": "choice",
                "choices": ("a", "b"),
                "case_sensitive": True,
            },
            id="Choice ParamType",
        ),
        pytest.param(
            click.DateTime(["%Y-%m-%d"]),
            {"param_type": "DateTime", "name": "datetime", "formats": ["%Y-%m-%d"]},
            id="DateTime ParamType",
        ),
        pytest.param(*INT_PARAM_TYPE, id="INT ParamType"),
        pytest.param(
            click.IntRange(0, 10, clamp=True),
            {
                "param_type": "IntRange",
                "name": "integer range",
                "min": 0,
                "max": 10,
                "min_open": False,
                "max_open": False,
                "clamp": True,
            },
            id="IntRange ParamType",
        ),
        pytest.param(
            click.FLOAT, {"param_type": "Float", "name": "float"}, id="FLOAT ParamType"
        ),
        pytest.param(
            click.FloatRange(-0.5, 0.5),
            {
                "param_type": "FloatRange",
                "name": "float range",
                "min": -0.5,
                "max": 0.5,
                "min_open": False,
                "max_open": False,
                "clamp": False,
            },
            id="FloatRange ParamType",
        ),
        pytest.param(*BOOL_PARAM_TYPE, id="Bool ParamType"),
        pytest.param(
            click.UUID, {"param_type": "UUID", "name": "uuid"}, id="UUID ParamType"
        ),
        pytest.param(
            click.File(),
            {"param_type": "File", "name": "filename", "mode": "r", "encoding": None},
            id="File ParamType",
        ),
        pytest.param(
            click.Path(),
            {
                "param_type": "Path",
                "name": "path",
                "exists": False,
                "file_okay": True,
                "dir_okay": True,
                "writable": False,
                "readable": True,
                "allow_dash": False,
            },
            id="Path ParamType",
        ),
        pytest.param(
            click.Tuple((click.STRING, click.INT)),
            {
                "param_type": "Tuple",
                "name": "<text integer>",
                "types": [STRING_PARAM_TYPE[1], INT_PARAM_TYPE[1]],
            },
            id="Tuple ParamType",
        ),
        pytest.param(*NUMBER_OPTION, id="Option"),
        pytest.param(
            click.Option(["--cache/--no-cache", "-c/-u"]),
            {
                "name": "cache",
                "param_type_name": "option",
                "opts": ["--cache", "-c"],
                "secondary_opts": ["--no-cache", "-u"],
                "type": BOOL_PARAM_TYPE[1],
                "required": False,
                "nargs": 1,
                "multiple": False,
                "default": False,
                "envvar": None,
                "help": None,
                "prompt": None,
                "is_flag": True,
                "flag_value": True,
                "count": False,
                "hidden": False,
            },
            id="Flag Option",
        ),
        pytest.param(*NAME_ARGUMENT, id="Argument"),
    ],
)
def test_parameter(obj, expect):
    out = obj.to_info_dict()
    assert out == expect


@pytest.mark.parametrize(
    ("obj", "expect"),
    [
        pytest.param(*HELLO_COMMAND, id="Command"),
        pytest.param(*HELLO_GROUP, id="Group"),
        pytest.param(
            click.Group(
                "base",
                [click.Command("test", params=[NAME_ARGUMENT[0]]), HELLO_GROUP[0]],
            ),
            {
                "name": "base",
                "params": [HELP_OPTION[1]],
                "help": None,
                "epilog": None,
                "short_help": None,
                "hidden": False,
                "deprecated": False,
                "commands": {
                    "cli": HELLO_GROUP[1],
                    "test": {
                        "name": "test",
                        "params": [NAME_ARGUMENT[1], HELP_OPTION[1]],
                        "help": None,
                        "epilog": None,
                        "short_help": None,
                        "hidden": False,
                        "deprecated": False,
                    },
                },
                "chain": False,
            },
            id="Nested Group",
        ),
    ],
)
def test_command(obj, expect):
    ctx = click.Context(obj)
    out = obj.to_info_dict(ctx)
    assert out == expect


def test_context():
    ctx = click.Context(HELLO_COMMAND[0])
    out = ctx.to_info_dict()
    assert out == {
        "command": HELLO_COMMAND[1],
        "info_name": None,
        "allow_extra_args": False,
        "allow_interspersed_args": True,
        "ignore_unknown_options": False,
        "auto_envvar_prefix": None,
    }


def test_paramtype_no_name():
    class TestType(click.ParamType):
        pass

    assert TestType().to_info_dict()["name"] == "TestType"


@pytest.mark.parametrize(
    ("help_in", "help_out"),
    [
        pytest.param(None, None, id="None"),
        pytest.param("", "", id="empty"),
        pytest.param("single line", "single line", id="single-line"),
        pytest.param(
            "\n    first line\n    second line\n    ",
            "first line\nsecond line",
            id="multi-line",
        ),
    ],
)
def test_argument_to_info_dict_help(help_in, help_out):
    arg = click.Argument(["name"], help=help_in)
    assert arg.to_info_dict()["help"] == help_out


def test_argument_to_info_dict_nargs():
    arg = click.Argument(["files"], nargs=-1, help="files to process")
    info = arg.to_info_dict()
    assert info["nargs"] == -1
    assert info["help"] == "files to process"


def test_command_to_info_dict_multiple_arguments():
    @click.command()
    @click.argument("src", help="source path")
    @click.argument("dst", help="destination path")
    def cli(src, dst):
        pass

    ctx = click.Context(cli)
    params = cli.to_info_dict(ctx)["params"]
    args = [p for p in params if p["param_type_name"] == "argument"]
    assert [p["name"] for p in args] == ["src", "dst"]
    assert [p["help"] for p in args] == ["source path", "destination path"]

//! Structured values.
//!
//! This module defines the [`Value`] type and supporting APIs for
//! capturing and serializing them.

use std::fmt;

pub use crate::kv::Error;

/// A type that can be converted into a [`Value`](struct.Value.html).
pub trait ToValue {
    /// Perform the conversion.
    fn to_value(&self) -> Value<'_>;
}

impl<T> ToValue for &T
where
    T: ToValue + ?Sized,
{
    fn to_value(&self) -> Value<'_> {
        (**self).to_value()
    }
}

impl<'v> ToValue for Value<'v> {
    fn to_value(&self) -> Value<'_> {
        Value {
            inner: self.inner.clone(),
        }
    }
}

/// A value in a key-value.
///
/// Values are an anonymous bag containing some structured datum.
///
/// # Capturing values
///
/// There are a few ways to capture a value:
///
/// - Using the `Value::from_*` methods.
/// - Using the `ToValue` trait.
/// - Using the standard `From` trait.
///
/// ## Using the `Value::from_*` methods
///
/// `Value` offers a few constructor methods that capture values of different kinds.
///
/// ```
/// use log::kv::Value;
///
/// let value = Value::from_debug(&42i32);
///
/// assert_eq!(None, value.to_i64());
/// ```
///
/// ## Using the `ToValue` trait
///
/// The `ToValue` trait can be used to capture values generically.
/// It's the bound used by `Source`.
///
/// ```
/// # use log::kv::ToValue;
/// let value = 42i32.to_value();
///
/// assert_eq!(Some(42), value.to_i64());
/// ```
///
/// ## Using the standard `From` trait
///
/// Standard types that implement `ToValue` also implement `From`.
///
/// ```
/// use log::kv::Value;
///
/// let value = Value::from(42i32);
///
/// assert_eq!(Some(42), value.to_i64());
/// ```
///
/// # Data model
///
/// Values can hold one of a number of types:
///
/// - **Null:** The absence of any other meaningful value. Note that
///   `Some(Value::null())` is not the same as `None`. The former is
///   `null` while the latter is `undefined`. This is important to be
///   able to tell the difference between a key-value that was logged,
///   but its value was empty (`Some(Value::null())`) and a key-value
///   that was never logged at all (`None`).
/// - **Strings:** `str`, `char`.
/// - **Booleans:** `bool`.
/// - **Integers:** `u8`-`u128`, `i8`-`i128`, `NonZero*`.
/// - **Floating point numbers:** `f32`-`f64`.
/// - **Errors:** `dyn (Error + 'static)`.
/// - **`serde`:** Any type in `serde`'s data model.
/// - **`sval`:** Any type in `sval`'s data model.
///
/// # Serialization
///
/// Values provide a number of ways to be serialized.
///
/// For basic types the [`Value::visit`] method can be used to extract the
/// underlying typed value. However, this is limited in the amount of types
/// supported (see the [`VisitValue`] trait methods).
///
/// For more complex types one of the following traits can be used:
///  * `sval::Value`, requires the `kv_sval` feature.
///  * `serde::Serialize`, requires the `kv_serde` feature.
///
/// You don't need a visitor to serialize values through `serde` or `sval`.
///
/// A value can always be serialized using any supported framework, regardless
/// of how it was captured. If, for example, a value was captured using its
/// `Display` implementation, it will serialize through `serde` as a string. If it was
/// captured as a struct using `serde`, it will also serialize as a struct
/// through `sval`, or can be formatted using a `Debug`-compatible representation.
#[derive(Clone)]
pub struct Value<'v> {
    inner: inner::Inner<'v>,
}

impl<'v> Value<'v> {
    /// Get a value from a type implementing `ToValue`.
    pub fn from_any<T>(value: &'v T) -> Self
    where
        T: ToValue,
    {
        value.to_value()
    }

    /// Get a value from a type implementing `std::fmt::Debug`.
    pub fn from_debug<T>(value: &'v T) -> Self
    where
        T: fmt::Debug,
    {
        Value {
            inner: inner::Inner::from_debug(value),
        }
    }

    /// Get a value from a type implementing `std::fmt::Display`.
    pub fn from_display<T>(value: &'v T) -> Self
    where
        T: fmt::Display,
    {
        Value {
            inner: inner::Inner::from_display(value),
        }
    }

    /// Get a value from a type implementing `serde::Serialize`.
    #[cfg(feature = "kv_serde")]
    pub fn from_serde<T>(value: &'v T) -> Self
    where
        T: serde_core::Serialize,
    {
        Value {
            inner: inner::Inner::from_serde1(value),
        }
    }

    /// Get a value from a type implementing `sval::Value`.
    #[cfg(feature = "kv_sval")]
    pub fn from_sval<T>(value: &'v T) -> Self
    where
        T: sval::Value,
    {
        Value {
            inner: inner::Inner::from_sval2(value),
        }
    }

    /// Get a value from a dynamic `std::fmt::Debug`.
    pub fn from_dyn_debug(value: &'v dyn fmt::Debug) -> Self {
        Value {
            inner: inner::Inner::from_dyn_debug(value),
        }
    }

    /// Get a value from a dynamic `std::fmt::Display`.
    pub fn from_dyn_display(value: &'v dyn fmt::Display) -> Self {
        Value {
            inner: inner::Inner::from_dyn_display(value),
        }
    }

    /// Get a value from a dynamic error.
    #[cfg(feature = "kv_std")]
    pub fn from_dyn_error(err: &'v (dyn std::error::Error + 'static)) -> Self {
        Value {
            inner: inner::Inner::from_dyn_error(err),
        }
    }

    /// Get a `null` value.
    pub fn null() -> Self {
        Value {
            inner: inner::Inner::empty(),
        }
    }

    /// Get a value from an internal primitive.
    fn from_inner<T>(value: T) -> Self
    where
        T: Into<inner::Inner<'v>>,
    {
        Value {
            inner: value.into(),
        }
    }

    /// Inspect this value using a simple visitor.
    ///
    /// When the `kv_serde` or `kv_sval` features are enabled, you can also
    /// serialize a value using its `Serialize` or `Value` implementation.
    pub fn visit(&self, visitor: impl VisitValue<'v>) -> Result<(), Error> {
        inner::visit(&self.inner, visitor)
    }
}

impl<'v> fmt::Debug for Value<'v> {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        fmt::Debug::fmt(&self.inner, f)
    }
}

impl<'v> fmt::Display for Value<'v> {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        fmt::Display::fmt(&self.inner, f)
    }
}

#[cfg(feature = "kv_serde")]
impl<'v> serde_core::Serialize for Value<'v> {
    fn serialize<S>(&self, s: S) -> Result<S::Ok, S::Error>
    where
        S: serde_core::Serializer,
    {
        self.inner.serialize(s)
    }
}

#[cfg(feature = "kv_sval")]
impl<'v> sval::Value for Value<'v> {
    fn stream<'sval, S: sval::Stream<'sval> + ?Sized>(&'sval self, stream: &mut S) -> sval::Result {
        sval::Value::stream(&self.inner, stream)
    }
}

#[cfg(feature = "kv_sval")]
impl<'v> sval_ref::ValueRef<'v> for Value<'v> {
    fn stream_ref<S: sval::Stream<'v> + ?Sized>(&self, stream: &mut S) -> sval::Result {
        sval_ref::ValueRef::stream_ref(&self.inner, stream)
    }
}

impl ToValue for str {
    fn to_value(&self) -> Value<'_> {
        Value::from(self)
    }
}

impl<'v> From<&'v str> for Value<'v> {
    fn from(value: &'v str) -> Self {
        Value::from_inner(value)
    }
}

impl ToValue for () {
    fn to_value(&self) -> Value<'_> {
        Value::from_inner(())
    }
}

impl<T> ToValue for Option<T>
where
    T: ToValue,
{
    fn to_value(&self) -> Value<'_> {
        match *self {
            Some(ref value) => value.to_value(),
            None => Value::from_inner(()),
        }
    }
}

macro_rules! impl_to_value_primitive {
    ($($into_ty:ty,)*) => {
        $(
            impl ToValue for $into_ty {
                fn to_value(&self) -> Value<'_> {
                    Value::from(*self)
                }
            }

            impl<'v> From<$into_ty> for Value<'v> {
                fn from(value: $into_ty) -> Self {
                    Value::from_inner(value)
                }
            }

            impl<'v> From<&'v $into_ty> for Value<'v> {
                fn from(value: &'v $into_ty) -> Self {
                    Value::from_inner(*value)
                }
            }
        )*
    };
}

macro_rules! impl_to_value_nonzero_primitive {
    ($($into_ty:ident,)*) => {
        $(
            impl ToValue for std::num::$into_ty {
                fn to_value(&self) -> Value<'_> {
                    Value::from(self.get())
                }
            }

            impl<'v> From<std::num::$into_ty> for Value<'v> {
                fn from(value: std::num::$into_ty) -> Self {
                    Value::from(value.get())
                }
            }

            impl<'v> From<&'v std::num::$into_ty> for Value<'v> {
                fn from(value: &'v std::num::$into_ty) -> Self {
                    Value::from(value.get())
                }
            }
        )*
    };
}

macro_rules! impl_value_to_primitive {
    ($(#[doc = $doc:tt] $into_name:ident -> $into_ty:ty,)*) => {
        impl<'v> Value<'v> {
            $(
                #[doc = $doc]
                pub fn $into_name(&self) -> Option<$into_ty> {
                    self.inner.$into_name()
                }
            )*
        }
    }
}

impl_to_value_primitive![
    usize, u8, u16, u32, u64, u128, isize, i8, i16, i32, i64, i128, f32, f64, char, bool,
];

#[rustfmt::skip]
impl_to_value_nonzero_primitive![
    NonZeroUsize, NonZeroU8, NonZeroU16, NonZeroU32, NonZeroU64, NonZeroU128,
    NonZeroIsize, NonZeroI8, NonZeroI16, NonZeroI32, NonZeroI64, NonZeroI128,
];

impl_value_to_primitive![
    #[doc = "Try convert this value into a `u64`."]
    to_u64 -> u64,
    #[doc = "Try convert this value into a `i64`."]
    to_i64 -> i64,
    #[doc = "Try convert this value into a `u128`."]
    to_u128 -> u128,
    #[doc = "Try convert this value into a `i128`."]
    to_i128 -> i128,
    #[doc = "Try convert this value into a `f64`."]
    to_f64 -> f64,
    #[doc = "Try convert this value into a `char`."]
    to_char -> char,
    #[doc = "Try convert this value into a `bool`."]
    to_bool -> bool,
];

#[cfg(feature = "std")]
macro_rules! impl_to_value_from_display {
    ($($into_ty:ty,)*) => {
        $(
            impl ToValue for $into_ty {
                fn to_value(&self) -> Value<'_> {
                    Value::from_display(self)
                }
            }

            impl<'v> From<&'v $into_ty> for Value<'v> {
                fn from(value: &'v $into_ty) -> Self {
                    Value::from_display(value)
                }
            }
        )*
    };
}

#[cfg(feature = "std")]
impl_to_value_from_display![
    std::net::IpAddr,
    std::net::Ipv4Addr,
    std::net::Ipv6Addr,
    std::net::SocketAddr,
    std::net::SocketAddrV4,
    std::net::SocketAddrV6,
];

impl<'v> Value<'v> {
    /// Try to convert this value into an error.
    #[cfg(feature = "kv_std")]
    pub fn to_borrowed_error(&self) -> Option<&(dyn std::error::Error + 'static)> {
        self.inner.to_borrowed_error()
    }

    /// Try to convert this value into a borrowed string.
    pub fn to_borrowed_str(&self) -> Option<&'v str> {
        self.inner.to_borrowed_str()
    }
}

#[cfg(feature = "std")]
mod std_support {
    use std::borrow::Cow;
    use std::rc::Rc;
    use std::sync::Arc;

    use super::*;

    impl<T> ToValue for Box<T>
    where
        T: ToValue + ?Sized,
    {
        fn to_value(&self) -> Value<'_> {
            (**self).to_value()
        }
    }

    impl<T> ToValue for Arc<T>
    where
        T: ToValue + ?Sized,
    {
        fn to_value(&self) -> Value<'_> {
            (**self).to_value()
        }
    }

    impl<T> ToValue for Rc<T>
    where
        T: ToValue + ?Sized,
    {
        fn to_value(&self) -> Value<'_> {
            (**self).to_value()
        }
    }

    impl ToValue for String {
        fn to_value(&self) -> Value<'_> {
            Value::from(&**self)
        }
    }

    impl<'v> ToValue for Cow<'v, str> {
        fn to_value(&self) -> Value<'_> {
            Value::from(&**self)
        }
    }

    #[cfg(feature = "kv_std")]
    impl<'v> Value<'v> {
        /// Try convert this value into a string.
        pub fn to_cow_str(&self) -> Option<Cow<'v, str>> {
            self.inner.to_str()
        }
    }

    impl<'v> From<&'v String> for Value<'v> {
        fn from(v: &'v String) -> Self {
            Value::from(&**v)
        }
    }
}

/// A visitor for a [`Value`].
///
/// Also see [`Value`'s documentation on serialization]. Value visitors are a simple alternative
/// to a more fully-featured serialization framework like `serde` or `sval`. A value visitor
/// can differentiate primitive types through methods like [`VisitValue::visit_bool`] and
/// [`VisitValue::visit_str`], but more complex types like maps and sequences
/// will fallthrough to [`VisitValue::visit_any`].
///
/// If you're trying to serialize a value to a format like JSON, you can use either `serde`
/// or `sval` directly with the value. You don't need a visitor.
///
/// [`Value`'s documentation on serialization]: Value#serialization
pub trait VisitValue<'v> {
    /// Visit a `Value`.
    ///
    /// This is the only required method on `VisitValue` and acts as a fallback for any
    /// more specific methods that aren't overridden.
    /// The `Value` may be formatted using its `fmt::Debug` or `fmt::Display` implementation,
    /// or serialized using its `sval::Value` or `serde::Serialize` implementation.
    fn visit_any(&mut self, value: Value) -> Result<(), Error>;

    /// Visit an empty value.
    fn visit_null(&mut self) -> Result<(), Error> {
        self.visit_any(Value::null())
    }

    /// Visit an unsigned integer.
    fn visit_u64(&mut self, value: u64) -> Result<(), Error> {
        self.visit_any(value.into())
    }

    /// Visit a signed integer.
    fn visit_i64(&mut self, value: i64) -> Result<(), Error> {
        self.visit_any(value.into())
    }

    /// Visit a big unsigned integer.
    fn visit_u128(&mut self, value: u128) -> Result<(), Error> {
        self.visit_any((value).into())
    }

    /// Visit a big signed integer.
    fn visit_i128(&mut self, value: i128) -> Result<(), Error> {
        self.visit_any((value).into())
    }

    /// Visit a floating point.
    fn visit_f64(&mut self, value: f64) -> Result<(), Error> {
        self.visit_any(value.into())
    }

    /// Visit a boolean.
    fn visit_bool(&mut self, value: bool) -> Result<(), Error> {
        self.visit_any(value.into())
    }

    /// Visit a string.
    fn visit_str(&mut self, value: &str) -> Result<(), Error> {
        self.visit_any(value.into())
    }

    /// Visit a string.
    fn visit_borrowed_str(&mut self, value: &'v str) -> Result<(), Error> {
        self.visit_str(value)
    }

    /// Visit a Unicode character.
    fn visit_char(&mut self, value: char) -> Result<(), Error> {
        let mut b = [0; 4];
        self.visit_str(&*value.encode_utf8(&mut b))
    }

    /// Visit an error.
    #[cfg(feature = "kv_std")]
    fn visit_error(&mut self, err: &(dyn std::error::Error + 'static)) -> Result<(), Error> {
        self.visit_any(Value::from_dyn_error(err))
    }

    /// Visit an error.
    #[cfg(feature = "kv_std")]
    fn visit_borrowed_error(
        &mut self,
        err: &'v (dyn std::error::Error + 'static),
    ) -> Result<(), Error> {
        self.visit_any(Value::from_dyn_error(err))
    }
}

#[allow(clippy::needless_lifetimes)] // Not needless.
impl<'a, 'v, T: ?Sized> VisitValue<'v> for &'a mut T
where
    T: VisitValue<'v>,
{
    fn visit_any(&mut self, value: Value) -> Result<(), Error> {
        (**self).visit_any(value)
    }

    fn visit_null(&mut self) -> Result<(), Error> {
        (**self).visit_null()
    }

    fn visit_u64(&mut self, value: u64) -> Result<(), Error> {
        (**self).visit_u64(value)
    }

    fn visit_i64(&mut self, value: i64) -> Result<(), Error> {
        (**self).visit_i64(value)
    }

    fn visit_u128(&mut self, value: u128) -> Result<(), Error> {
        (**self).visit_u128(value)
    }

    fn visit_i128(&mut self, value: i128) -> Result<(), Error> {
        (**self).visit_i128(value)
    }

    fn visit_f64(&mut self, value: f64) -> Result<(), Error> {
        (**self).visit_f64(value)
    }

    fn visit_bool(&mut self, value: bool) -> Result<(), Error> {
        (**self).visit_bool(value)
    }

    fn visit_str(&mut self, value: &str) -> Result<(), Error> {
        (**self).visit_str(value)
    }

    fn visit_borrowed_str(&mut self, value: &'v str) -> Result<(), Error> {
        (**self).visit_borrowed_str(value)
    }

    fn visit_char(&mut self, value: char) -> Result<(), Error> {
        (**self).visit_char(value)
    }

    #[cfg(feature = "kv_std")]
    fn visit_error(&mut self, err: &(dyn std::error::Error + 'static)) -> Result<(), Error> {
        (**self).visit_error(err)
    }

    #[cfg(feature = "kv_std")]
    fn visit_borrowed_error(
        &mut self,
        err: &'v (dyn std::error::Error + 'static),
    ) -> Result<(), Error> {
        (**self).visit_borrowed_error(err)
    }
}

#[cfg(feature = "value-bag")]
pub(in crate::kv) mod inner {
    /**
    An implementation of `Value` based on a library called `value_bag`.

    `value_bag` was written specifically for use in `log`'s value, but was split out when it outgrew
    the codebase here. It's a general-purpose type-erasure library that handles mapping between
    more fully-featured serialization frameworks.
    */
    use super::*;

    pub use value_bag::ValueBag as Inner;

    pub use value_bag::Error;

    #[cfg(test)]
    pub use value_bag::test::TestToken as Token;

    pub fn visit<'v>(
        inner: &Inner<'v>,
        visitor: impl VisitValue<'v>,
    ) -> Result<(), crate::kv::Error> {
        struct InnerVisitValue<V>(V);

        impl<'v, V> value_bag::visit::Visit<'v> for InnerVisitValue<V>
        where
            V: VisitValue<'v>,
        {
            fn visit_any(&mut self, value: value_bag::ValueBag) -> Result<(), Error> {
                self.0
                    .visit_any(Value { inner: value })
                    .map_err(crate::kv::Error::into_value)
            }

            fn visit_empty(&mut self) -> Result<(), Error> {
                self.0.visit_null().map_err(crate::kv::Error::into_value)
            }

            fn visit_u64(&mut self, value: u64) -> Result<(), Error> {
                self.0
                    .visit_u64(value)
                    .map_err(crate::kv::Error::into_value)
            }

            fn visit_i64(&mut self, value: i64) -> Result<(), Error> {
                self.0
                    .visit_i64(value)
                    .map_err(crate::kv::Error::into_value)
            }

            fn visit_u128(&mut self, value: u128) -> Result<(), Error> {
                self.0
                    .visit_u128(value)
                    .map_err(crate::kv::Error::into_value)
            }

            fn visit_i128(&mut self, value: i128) -> Result<(), Error> {
                self.0
                    .visit_i128(value)
                    .map_err(crate::kv::Error::into_value)
            }

            fn visit_f64(&mut self, value: f64) -> Result<(), Error> {
                self.0
                    .visit_f64(value)
                    .map_err(crate::kv::Error::into_value)
            }

            fn visit_bool(&mut self, value: bool) -> Result<(), Error> {
                self.0
                    .visit_bool(value)
                    .map_err(crate::kv::Error::into_value)
            }

            fn visit_str(&mut self, value: &str) -> Result<(), Error> {
                self.0
                    .visit_str(value)
                    .map_err(crate::kv::Error::into_value)
            }

            fn visit_borrowed_str(&mut self, value: &'v str) -> Result<(), Error> {
                self.0
                    .visit_borrowed_str(value)
                    .map_err(crate::kv::Error::into_value)
            }

            fn visit_char(&mut self, value: char) -> Result<(), Error> {
                self.0
                    .visit_char(value)
                    .map_err(crate::kv::Error::into_value)
            }

            #[cfg(feature = "kv_std")]
            fn visit_error(
                &mut self,
                err: &(dyn std::error::Error + 'static),
            ) -> Result<(), Error> {
                self.0
                    .visit_error(err)
                    .map_err(crate::kv::Error::into_value)
            }

            #[cfg(feature = "kv_std")]
            fn visit_borrowed_error(
                &mut self,
                err: &'v (dyn std::error::Error + 'static),
            ) -> Result<(), Error> {
                self.0
                    .visit_borrowed_error(err)
                    .map_err(crate::kv::Error::into_value)
            }
        }

        inner
            .visit(&mut InnerVisitValue(visitor))
            .map_err(crate::kv::Error::from_value)
    }
}

#[cfg(not(feature = "value-bag"))]
pub(in crate::kv) mod inner {
    /**
    This is a dependency-free implementation of `Value` when there's no serialization frameworks involved.
    In these simple cases a more fully featured solution like `value_bag` isn't needed, so we avoid pulling it in.

    There are a few things here that need to remain consistent with the `value_bag`-based implementation:

    1. Conversions should always produce the same results. If a conversion here returns `Some`, then
       the same `value_bag`-based conversion must also. Of particular note here are floats to ints; they're
       based on the standard library's `TryInto` conversions, which need to be converted to `i32` or `u32`,
       and then to `f64`.
    2. VisitValues should always be called in the same way. If a particular type of value calls `visit_i64`,
       then the same `value_bag`-based visitor must also.
    */
    use super::*;

    #[derive(Clone)]
    pub enum Inner<'v> {
        // NOTE: New variants can't be added here; see the module-level doc above
        None,
        Bool(bool),
        Str(&'v str),
        Char(char),
        I64(i64),
        U64(u64),
        F64(f64),
        I128(i128),
        U128(u128),
        Debug(&'v dyn fmt::Debug),
        Display(&'v dyn fmt::Display),
    }

    impl<'v> From<()> for Inner<'v> {
        fn from(_: ()) -> Self {
            Inner::None
        }
    }

    impl<'v> From<bool> for Inner<'v> {
        fn from(v: bool) -> Self {
            Inner::Bool(v)
        }
    }

    impl<'v> From<char> for Inner<'v> {
        fn from(v: char) -> Self {
            Inner::Char(v)
        }
    }

    impl<'v> From<f32> for Inner<'v> {
        fn from(v: f32) -> Self {
            Inner::F64(v as f64)
        }
    }

    impl<'v> From<f64> for Inner<'v> {
        fn from(v: f64) -> Self {
            Inner::F64(v)
        }
    }

    impl<'v> From<i8> for Inner<'v> {
        fn from(v: i8) -> Self {
            Inner::I64(v as i64)
        }
    }

    impl<'v> From<i16> for Inner<'v> {
        fn from(v: i16) -> Self {
            Inner::I64(v as i64)
        }
    }

    impl<'v> From<i32> for Inner<'v> {
        fn from(v: i32) -> Self {
            Inner::I64(v as i64)
        }
    }

    impl<'v> From<i64> for Inner<'v> {
        fn from(v: i64) -> Self {
            Inner::I64(v as i64)
        }
    }

    impl<'v> From<isize> for Inner<'v> {
        fn from(v: isize) -> Self {
            Inner::I64(v as i64)
        }
    }

    impl<'v> From<u8> for Inner<'v> {
        fn from(v: u8) -> Self {
            Inner::U64(v as u64)
        }
    }

    impl<'v> From<u16> for Inner<'v> {
        fn from(v: u16) -> Self {
            Inner::U64(v as u64)
        }
    }

    impl<'v> From<u32> for Inner<'v> {
        fn from(v: u32) -> Self {
            Inner::U64(v as u64)
        }
    }

    impl<'v> From<u64> for Inner<'v> {
        fn from(v: u64) -> Self {
            Inner::U64(v as u64)
        }
    }

    impl<'v> From<usize> for Inner<'v> {
        fn from(v: usize) -> Self {
            Inner::U64(v as u64)
        }
    }

    impl<'v> From<i128> for Inner<'v> {
        fn from(v: i128) -> Self {
            Inner::I128(v)
        }
    }

    impl<'v> From<u128> for Inner<'v> {
        fn from(v: u128) -> Self {
            Inner::U128(v)
        }
    }

    impl<'v> From<&'v str> for Inner<'v> {
        fn from(v: &'v str) -> Self {
            Inner::Str(v)
        }
    }

    impl<'v> fmt::Debug for Inner<'v> {
        fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
            match self {
                Inner::None => fmt::Debug::fmt(&None::<()>, f),
                Inner::Bool(v) => fmt::Debug::fmt(v, f),
                Inner::Str(v) => fmt::Debug::fmt(v, f),
                Inner::Char(v) => fmt::Debug::fmt(v, f),
                Inner::I64(v) => fmt::Debug::fmt(v, f),
                Inner::U64(v) => fmt::Debug::fmt(v, f),
                Inner::F64(v) => fmt::Debug::fmt(v, f),
                Inner::I128(v) => fmt::Debug::fmt(v, f),
                Inner::U128(v) => fmt::Debug::fmt(v, f),
                Inner::Debug(v) => fmt::Debug::fmt(v, f),
                Inner::Display(v) => fmt::Display::fmt(v, f),
            }
        }
    }

    impl<'v> fmt::Display for Inner<'v> {
        fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
            match self {
                Inner::None => fmt::Debug::fmt(&None::<()>, f),
                Inner::Bool(v) => fmt::Display::fmt(v, f),
                Inner::Str(v) => fmt::Display::fmt(v, f),
                Inner::Char(v) => fmt::Display::fmt(v, f),
                Inner::I64(v) => fmt::Display::fmt(v, f),
                Inner::U64(v) => fmt::Display::fmt(v, f),
                Inner::F64(v) => fmt::Display::fmt(v, f),
                Inner::I128(v) => fmt::Display::fmt(v, f),
                Inner::U128(v) => fmt::Display::fmt(v, f),
                Inner::Debug(v) => fmt::Debug::fmt(v, f),
                Inner::Display(v) => fmt::Display::fmt(v, f),
            }
        }
    }

    impl<'v> Inner<'v> {
        pub fn from_debug<T: fmt::Debug>(value: &'v T) -> Self {
            Inner::Debug(value)
        }

        pub fn from_display<T: fmt::Display>(value: &'v T) -> Self {
            Inner::Display(value)
        }

        pub fn from_dyn_debug(value: &'v dyn fmt::Debug) -> Self {
            Inner::Debug(value)
        }

        pub fn from_dyn_display(value: &'v dyn fmt::Display) -> Self {
            Inner::Display(value)
        }

        pub fn empty() -> Self {
            Inner::None
        }

        pub fn to_bool(&self) -> Option<bool> {
            match self {
                Inner::Bool(v) => Some(*v),
                _ => None,
            }
        }

        pub fn to_char(&self) -> Option<char> {
            match self {
                Inner::Char(v) => Some(*v),
                _ => None,
            }
        }

        pub fn to_f64(&self) -> Option<f64> {
            match self {
                Inner::F64(v) => Some(*v),
                Inner::I64(v) => {
                    let v: i32 = (*v).try_into().ok()?;
                    v.try_into().ok()
                }
                Inner::U64(v) => {
                    let v: u32 = (*v).try_into().ok()?;
                    v.try_into().ok()
                }
                Inner::I128(v) => {
                    let v: i32 = (*v).try_into().ok()?;
                    v.try_into().ok()
                }
                Inner::U128(v) => {
                    let v: u32 = (*v).try_into().ok()?;
                    v.try_into().ok()
                }
                _ => None,
            }
        }

        pub fn to_i64(&self) -> Option<i64> {
            match self {
                Inner::I64(v) => Some(*v),
                Inner::U64(v) => (*v).try_into().ok(),
                Inner::I128(v) => (*v).try_into().ok(),
                Inner::U128(v) => (*v).try_into().ok(),
                _ => None,
            }
        }

        pub fn to_u64(&self) -> Option<u64> {
            match self {
                Inner::U64(v) => Some(*v),
                Inner::I64(v) => (*v).try_into().ok(),
                Inner::I128(v) => (*v).try_into().ok(),
                Inner::U128(v) => (*v).try_into().ok(),
                _ => None,
            }
        }

        pub fn to_u128(&self) -> Option<u128> {
            match self {
                Inner::U128(v) => Some(*v),
                Inner::I64(v) => (*v).try_into().ok(),
                Inner::U64(v) => (*v).try_into().ok(),
                Inner::I128(v) => (*v).try_into().ok(),
                _ => None,
            }
        }

        pub fn to_i128(&self) -> Option<i128> {
            match self {
                Inner::I128(v) => Some(*v),
                Inner::I64(v) => (*v).try_into().ok(),
                Inner::U64(v) => (*v).try_into().ok(),
                Inner::U128(v) => (*v).try_into().ok(),
                _ => None,
            }
        }

        pub fn to_borrowed_str(&self) -> Option<&'v str> {
            match self {
                Inner::Str(v) => Some(v),
                _ => None,
            }
        }

        #[cfg(test)]
        pub fn to_test_token(&self) -> Token<'_> {
            match self {
                Inner::None => Token::None,
                Inner::Bool(v) => Token::Bool(*v),
                Inner::Str(v) => Token::Str(*v),
                Inner::Char(v) => Token::Char(*v),
                Inner::I64(v) => Token::I64(*v),
                Inner::U64(v) => Token::U64(*v),
                Inner::F64(v) => Token::F64(*v),
                Inner::I128(_) => unimplemented!(),
                Inner::U128(_) => unimplemented!(),
                Inner::Debug(_) => unimplemented!(),
                Inner::Display(_) => unimplemented!(),
            }
        }
    }

    #[cfg(test)]
    #[derive(Debug, PartialEq)]
    pub enum Token<'v> {
        None,
        Bool(bool),
        Char(char),
        Str(&'v str),
        F64(f64),
        I64(i64),
        U64(u64),
    }

    pub fn visit<'v>(
        inner: &Inner<'v>,
        mut visitor: impl VisitValue<'v>,
    ) -> Result<(), crate::kv::Error> {
        match inner {
            Inner::None => visitor.visit_null(),
            Inner::Bool(v) => visitor.visit_bool(*v),
            Inner::Str(v) => visitor.visit_borrowed_str(*v),
            Inner::Char(v) => visitor.visit_char(*v),
            Inner::I64(v) => visitor.visit_i64(*v),
            Inner::U64(v) => visitor.visit_u64(*v),
            Inner::F64(v) => visitor.visit_f64(*v),
            Inner::I128(v) => visitor.visit_i128(*v),
            Inner::U128(v) => visitor.visit_u128(*v),
            Inner::Debug(v) => visitor.visit_any(Value::from_dyn_debug(*v)),
            Inner::Display(v) => visitor.visit_any(Value::from_dyn_display(*v)),
        }
    }
}

impl<'v> Value<'v> {
    /// Get a value from a type implementing `std::fmt::Debug`.
    #[cfg(feature = "kv_unstable")]
    #[deprecated(note = "use `from_debug` instead")]
    pub fn capture_debug<T>(value: &'v T) -> Self
    where
        T: fmt::Debug + 'static,
    {
        Value::from_debug(value)
    }

    /// Get a value from a type implementing `std::fmt::Display`.
    #[cfg(feature = "kv_unstable")]
    #[deprecated(note = "use `from_display` instead")]
    pub fn capture_display<T>(value: &'v T) -> Self
    where
        T: fmt::Display + 'static,
    {
        Value::from_display(value)
    }

    /// Get a value from an error.
    #[cfg(feature = "kv_unstable_std")]
    #[deprecated(note = "use `from_dyn_error` instead")]
    pub fn capture_error<T>(err: &'v T) -> Self
    where
        T: std::error::Error + 'static,
    {
        Value::from_dyn_error(err)
    }

    /// Get a value from a type implementing `serde::Serialize`.
    #[cfg(feature = "kv_unstable_serde")]
    #[deprecated(note = "use `from_serde` instead")]
    pub fn capture_serde<T>(value: &'v T) -> Self
    where
        T: serde_core::Serialize + 'static,
    {
        Value::from_serde(value)
    }

    /// Get a value from a type implementing `sval::Value`.
    #[cfg(feature = "kv_unstable_sval")]
    #[deprecated(note = "use `from_sval` instead")]
    pub fn capture_sval<T>(value: &'v T) -> Self
    where
        T: sval::Value + 'static,
    {
        Value::from_sval(value)
    }

    /// Check whether this value can be downcast to `T`.
    #[cfg(feature = "kv_unstable")]
    #[deprecated(
        note = "downcasting has been removed; log an issue at https://github.com/rust-lang/log/issues if this is something you rely on"
    )]
    pub fn is<T: 'static>(&self) -> bool {
        false
    }

    /// Try downcast this value to `T`.
    #[cfg(feature = "kv_unstable")]
    #[deprecated(
        note = "downcasting has been removed; log an issue at https://github.com/rust-lang/log/issues if this is something you rely on"
    )]
    pub fn downcast_ref<T: 'static>(&self) -> Option<&T> {
        None
    }
}

// NOTE: Deprecated; but aliases can't carry this attribute
#[cfg(feature = "kv_unstable")]
pub use VisitValue as Visit;

/// Get a value from a type implementing `std::fmt::Debug`.
#[cfg(feature = "kv_unstable")]
#[deprecated(note = "use the `key:? = value` macro syntax instead")]
#[macro_export]
macro_rules! as_debug {
    ($capture:expr) => {
        $crate::kv::Value::from_debug(&$capture)
    };
}

/// Get a value from a type implementing `std::fmt::Display`.
#[cfg(feature = "kv_unstable")]
#[deprecated(note = "use the `key:% = value` macro syntax instead")]
#[macro_export]
macro_rules! as_display {
    ($capture:expr) => {
        $crate::kv::Value::from_display(&$capture)
    };
}

/// Get a value from an error.
#[cfg(feature = "kv_unstable_std")]
#[deprecated(note = "use the `key:err = value` macro syntax instead")]
#[macro_export]
macro_rules! as_error {
    ($capture:expr) => {
        $crate::kv::Value::from_dyn_error(&$capture)
    };
}

#[cfg(feature = "kv_unstable_serde")]
#[deprecated(note = "use the `key:serde = value` macro syntax instead")]
/// Get a value from a type implementing `serde::Serialize`.
#[macro_export]
macro_rules! as_serde {
    ($capture:expr) => {
        $crate::kv::Value::from_serde(&$capture)
    };
}

/// Get a value from a type implementing `sval::Value`.
#[cfg(feature = "kv_unstable_sval")]
#[deprecated(note = "use the `key:sval = value` macro syntax instead")]
#[macro_export]
macro_rules! as_sval {
    ($capture:expr) => {
        $crate::kv::Value::from_sval(&$capture)
    };
}

#[cfg(test)]
pub(crate) mod tests {
    use super::*;

    // For new `ToValue` implementations, also add a test to the `tests/macros` file

    impl<'v> Value<'v> {
        #[allow(mismatched_lifetime_syntaxes)]
        pub(crate) fn to_token(&self) -> inner::Token {
            self.inner.to_test_token()
        }
    }

    fn unsigned() -> impl Iterator<Item = Value<'static>> {
        vec![
            Value::from(8u8),
            Value::from(16u16),
            Value::from(32u32),
            Value::from(64u64),
            Value::from(1usize),
            Value::from(std::num::NonZeroU8::new(8).unwrap()),
            Value::from(std::num::NonZeroU16::new(16).unwrap()),
            Value::from(std::num::NonZeroU32::new(32).unwrap()),
            Value::from(std::num::NonZeroU64::new(64).unwrap()),
            Value::from(std::num::NonZeroUsize::new(1).unwrap()),
        ]
        .into_iter()
    }

    fn signed() -> impl Iterator<Item = Value<'static>> {
        vec![
            Value::from(-8i8),
            Value::from(-16i16),
            Value::from(-32i32),
            Value::from(-64i64),
            Value::from(-1isize),
            Value::from(std::num::NonZeroI8::new(-8).unwrap()),
            Value::from(std::num::NonZeroI16::new(-16).unwrap()),
            Value::from(std::num::NonZeroI32::new(-32).unwrap()),
            Value::from(std::num::NonZeroI64::new(-64).unwrap()),
            Value::from(std::num::NonZeroIsize::new(-1).unwrap()),
        ]
        .into_iter()
    }

    fn float() -> impl Iterator<Item = Value<'static>> {
        vec![Value::from(32.32f32), Value::from(64.64f64)].into_iter()
    }

    fn bool() -> impl Iterator<Item = Value<'static>> {
        vec![Value::from(true), Value::from(false)].into_iter()
    }

    fn str() -> impl Iterator<Item = Value<'static>> {
        vec![Value::from("a string"), Value::from("a loong string")].into_iter()
    }

    fn char() -> impl Iterator<Item = Value<'static>> {
        vec![Value::from('a'), Value::from('⛰')].into_iter()
    }

    #[test]
    fn test_to_value_display() {
        assert_eq!(42u64.to_value().to_string(), "42");
        assert_eq!(42i64.to_value().to_string(), "42");
        assert_eq!(42.01f64.to_value().to_string(), "42.01");
        assert_eq!(true.to_value().to_string(), "true");
        assert_eq!('a'.to_value().to_string(), "a");
        assert_eq!("a loong string".to_value().to_string(), "a loong string");
        assert_eq!(Some(true).to_value().to_string(), "true");
        assert_eq!(().to_value().to_string(), "None");
        assert_eq!(None::<bool>.to_value().to_string(), "None");
    }

    #[test]
    #[cfg(feature = "std")]
    fn test_net_to_value_display() {
        use std::str::FromStr;

        assert_eq!(
            std::net::Ipv4Addr::new(192, 168, 10, 100)
                .to_value()
                .to_string(),
            "192.168.10.100"
        );
        assert_eq!(
            std::net::Ipv6Addr::from_str("f33c::1")
                .unwrap()
                .to_value()
                .to_string(),
            "f33c::1"
        );
        assert_eq!(
            std::net::IpAddr::V4(std::net::Ipv4Addr::new(192, 168, 10, 100))
                .to_value()
                .to_string(),
            "192.168.10.100"
        );
        assert_eq!(
            std::net::IpAddr::V6(std::net::Ipv6Addr::from_str("f33c::1").unwrap())
                .to_value()
                .to_string(),
            "f33c::1"
        );
        assert_eq!(
            std::net::SocketAddrV4::new(std::net::Ipv4Addr::new(192, 168, 10, 100), 12345)
                .to_value()
                .to_string(),
            "192.168.10.100:12345"
        );
        assert_eq!(
            std::net::SocketAddrV6::new(
                std::net::Ipv6Addr::from_str("f33c::1").unwrap(),
                12345,
                0,
                0
            )
            .to_value()
            .to_string(),
            "[f33c::1]:12345"
        );
        assert_eq!(
            std::net::SocketAddr::V4(std::net::SocketAddrV4::new(
                std::net::Ipv4Addr::new(192, 168, 10, 100),
                12345
            ))
            .to_value()
            .to_string(),
            "192.168.10.100:12345"
        );
        assert_eq!(
            std::net::SocketAddr::V6(std::net::SocketAddrV6::new(
                std::net::Ipv6Addr::from_str("f33c::1").unwrap(),
                12345,
                0,
                0
            ))
            .to_value()
            .to_string(),
            "[f33c::1]:12345"
        );
    }

    #[test]
    fn test_to_value_structured() {
        assert_eq!(42u64.to_value().to_token(), inner::Token::U64(42));
        assert_eq!(42i64.to_value().to_token(), inner::Token::I64(42));
        assert_eq!(42.01f64.to_value().to_token(), inner::Token::F64(42.01));
        assert_eq!(true.to_value().to_token(), inner::Token::Bool(true));
        assert_eq!('a'.to_value().to_token(), inner::Token::Char('a'));
        assert_eq!(
            "a loong string".to_value().to_token(),
            inner::Token::Str("a loong string".into())
        );
        assert_eq!(Some(true).to_value().to_token(), inner::Token::Bool(true));
        assert_eq!(().to_value().to_token(), inner::Token::None);
        assert_eq!(None::<bool>.to_value().to_token(), inner::Token::None);
    }

    #[test]
    fn test_to_number() {
        for v in unsigned() {
            assert!(v.to_u64().is_some());
            assert!(v.to_i64().is_some());
        }

        for v in signed() {
            assert!(v.to_i64().is_some());
        }

        for v in unsigned().chain(signed()).chain(float()) {
            assert!(v.to_f64().is_some());
        }

        for v in bool().chain(str()).chain(char()) {
            assert!(v.to_u64().is_none());
            assert!(v.to_i64().is_none());
            assert!(v.to_f64().is_none());
        }
    }

    #[test]
    fn test_to_float() {
        // Only integers from i32::MIN..=u32::MAX can be converted into floats
        assert!(Value::from(i32::MIN).to_f64().is_some());
        assert!(Value::from(u32::MAX).to_f64().is_some());

        assert!(Value::from((i32::MIN as i64) - 1).to_f64().is_none());
        assert!(Value::from((u32::MAX as u64) + 1).to_f64().is_none());
    }

    #[test]
    fn test_to_cow_str() {
        for v in str() {
            assert!(v.to_borrowed_str().is_some());

            #[cfg(feature = "kv_std")]
            assert!(v.to_cow_str().is_some());
        }

        let short_lived = String::from("short lived");
        let v = Value::from(&*short_lived);

        assert!(v.to_borrowed_str().is_some());

        #[cfg(feature = "kv_std")]
        assert!(v.to_cow_str().is_some());

        for v in unsigned().chain(signed()).chain(float()).chain(bool()) {
            assert!(v.to_borrowed_str().is_none());

            #[cfg(feature = "kv_std")]
            assert!(v.to_cow_str().is_none());
        }
    }

    #[test]
    fn test_to_bool() {
        for v in bool() {
            assert!(v.to_bool().is_some());
        }

        for v in unsigned()
            .chain(signed())
            .chain(float())
            .chain(str())
            .chain(char())
        {
            assert!(v.to_bool().is_none());
        }
    }

    #[test]
    fn test_to_char() {
        for v in char() {
            assert!(v.to_char().is_some());
        }

        for v in unsigned()
            .chain(signed())
            .chain(float())
            .chain(str())
            .chain(bool())
        {
            assert!(v.to_char().is_none());
        }
    }

    #[test]
    fn test_visit_integer() {
        struct Extract(Option<u64>);

        impl<'v> VisitValue<'v> for Extract {
            fn visit_any(&mut self, value: Value) -> Result<(), Error> {
                unimplemented!("unexpected value: {value:?}")
            }

            fn visit_u64(&mut self, value: u64) -> Result<(), Error> {
                self.0 = Some(value);

                Ok(())
            }
        }

        let mut extract = Extract(None);
        Value::from(42u64).visit(&mut extract).unwrap();

        assert_eq!(Some(42), extract.0);
    }

    #[test]
    fn test_visit_borrowed_str() {
        struct Extract<'v>(Option<&'v str>);

        impl<'v> VisitValue<'v> for Extract<'v> {
            fn visit_any(&mut self, value: Value) -> Result<(), Error> {
                unimplemented!("unexpected value: {value:?}")
            }

            fn visit_borrowed_str(&mut self, value: &'v str) -> Result<(), Error> {
                self.0 = Some(value);

                Ok(())
            }
        }

        let mut extract = Extract(None);

        let short_lived = String::from("A short-lived string");
        Value::from(&*short_lived).visit(&mut extract).unwrap();

        assert_eq!(Some("A short-lived string"), extract.0);
    }
}

Internet Society hay ISOC là một tổ chức quốc tế hoạt động phi lợi nhuận, phi chính phủ và bao gồm các thành viên có trình độ chuyên ngành. Tổ chức này chú trọng đến: tiêu chuẩn, giáo dục và các vấn đề về chính sách. Với trên 145 tổ chức thành viên và 65.000 thành viên cá nhân, ISOC bao gồm những con người cụ thể trong cộng đồng Internet. Mọi chi tiết có thể tìm thấy tại website của ISOC.

Internet Society nằm ở gần thủ đô Washington, DC, Hoa Kỳ và Geneva, Thụy Sĩ. Số hội viên của nó bao gồm hơn 145 tổ chức thành viên và hơn 65.000 cá nhân. Thành viên còn có thể tự lập một chi nhánh của tổ chức tùy theo vị trí hoặc sở thích. Hiện nay tổ chức có tới 90 chi nhánh trên toàn thế giới.

Nhiệm vụ và mục đích hoạt động
Bảo đảm, cổ vũ cho sự phát triển, mở rộng và sử dụng Internet được thuận lợi nhất cho mọi người trên toàn thế giới.

Xem thêm
Lịch sử Internet

Tham khảo

Liên kết ngoài
 
 
 ISOC Việt Nam
 IETF and the Internet Society - Về Internet Engineering Task Force và ISOC, bài của Vint Cerf 18/7/1995
 L’Association Internationale de Lutte Contre la Cybercriminalité bản lưu
 Public Interest Registry

Internet
Tổ chức quốc tế
Tổ chức phi lợi nhuận
Tiêu chuẩn Internet
Khởi đầu năm 1992
Quản lý Internet

သမိုင်းဆိုသည်မှာ လူသားတို့၏ အတိတ်ကာလကို လေ့လာသော ဘာသာရပ်ဖြစ်သည်။ စာရေးသားခြင်းကို တီထွင်ပြီးသည့်နောက်တွင် သမိုင်းပေါ်ပေါက်လာခဲ့သည်ဟုလည်း ဆိုနိုင်သည်။ သမိုင်းကို ရေးသားသော ပညာရှင်များကို သမိုင်းပညာရှင်ဟု ခေါ်ဆိုလေ့ရှိကြသည်။ ၎င်းမှာ ပြန်ပြောင်းပြောဆိုချက်များကို အသုံးပြု၍ ဆက်တိုက်ဖြစ်ပျက် ခဲ့သော အဖြစ်အပျက်များကို စစ်ဆေးခြင်းနှင့် ခွဲခြမ်းစိတ်ဖြာခြင်း ပြုသော သုတေသန နယ်ပယ် ဖြစ်ကာ တစ်ခါတရံတွင် အကျိုးအကြောင်း ဆက်နွယ်၍ ဖြစ်ပျက်ခဲ့သော အဖြစ်အပျက်များကို ဓမ္မဓိဋ္ဌာန်ကျကျ စုံစမ်းစစ်ဆေးကာ ဆုံးဖြတ်သော ပညာရပ်ပင် ဖြစ်သည်။ သမိုင်းပညာရှင်များသည် သမိုင်း၏ သဘောသဘာဝ နှင့် အသုံးဝင်မှုတို့ကို ငြင်းခုံလေ့ ရှိကြသည်။

မြန်မာ့စွယ်စုံကျမ်းမှ သမိုင်း 
သမိုင်းဟူသည်မှာ အတိတ်ကဖြစ်ရပ်များကိုလေ့လာမှတ်ကျောက်တင်ထားသောစာကိုဆိုလိုသည်။ ဘုရား၊ ဂူ၊ ကျောင်း၊ တန်ဆောင်း၊ စဆွံ၊ ဓမ္မသာလာ၊ တန်တား၊ ပုဂ္ဂိုလ်ထူး၊အကြောင်းအရာထူး စသည်တို့နှင့်စပ်လျဉ်း၍ စကားပြေဖြင့် ဖြစ်စေလင်္ကာဖြင့်ဖြစ်စေ စီကုံးရေးသားထားသည်များကိုသမိုင်းဟုခေါ်သည်။ 

အချို့ကလည်း သမိုင်းသည်သံပိုင်းနှင့်သဘောချင်းတူပြီးလျှင် သံပိုင်းမှသမ္ပိုင်း၊ သမိုင်းဖြစ်လာသည်ဟုဆိုကြသည်။ စကားပြေဖြင့်ရေးသားထားသော သမိုင်းများအကြောင်းကို အထူးမရေးသားတော့ဘဲ လင်္ကာစပ်ဆိုထားသောသမိုင်းရေးသားနည်းကိုဖော်ပြပေအံ့။ သမိုင်းလင်္ကာစပ်ဆိုရာ၌-
 လင်္ကာစပ်ဆိုနည်းများ အတိုင်းရေး သွားသည်။ 
 အစမှာဖြစ်စေ၊ အဆုံးမှာဖြစ်စေ သမိုင်းဟူသောစကား များသောအားဖြင့်ပါရှိတတ်သည်။ 

ပုံစံအားဖြင့်သမိုင်းတန်ဆောင်၊ ကမ္ပည်းဆောင်အံ့၊ ဉာဏ်ရောင်ဖြန့်ချိ၊နှိုင်းချိန်ညှိလော့၊လောကီအရာ စသည်ဖြင့် သမိုင်း လင်္ကာမှန်းသိအောင် သမိုင်းဆိုသည့်ပုဒ်ကို 
ထည့်စပ်လေ့ရှိကြသည်။ သမိုင်းဟူသည့်ပုဒ်ကိုလင်္ကာ၏ အလယ်၌သမိုင်းမှန်းသိအောင်ထည့်သွင်းစပ်ဆိုသည်လည်းရှိသည်။ ပုံစံအားဖြင့်စစ်ကိုင်းမြို့ သမိုင်းလင်္ကာတွင်
 ရန်မာန်ပယ်ခိုင်း၊မြို့စစ်ကိုင်း၏၊သမိုင်းလင်္ကာ၊ ဂုဏ်ကိုးဖြာအား ဟူ၍လည်းကောင်း၊ ရှင်ပင်သက်တော်ရဘုရားသမိုင်းတွင် မင်္ဂလာ ထုံးဆောင်၊ကပ်လုံးပြောင်စိမ့်၊ အခေါင်သာနှိုင်း၊ တပေါင်လှိုင်း၍၊တိုင်းမြန်မာပြည်၊ သမိုင်းရှည်ဖြင့်၊ ငါးမည်အင်စုံ ဟူ၍လည်းကောင်း အသီးသီးစပ်ဆိုကြသည်။ 

အချို့သမိုင်းလင်္ကာစာကိုယ်များ၌မူ သမိုင်းဟူသောစာပုဒ်လုံးဝ မပါပဲလည်းရှိတတ်သည်။ ပုံစံအားဖြင့်ပုဂံပညာရှိမွန်း
ကိုဆိုပုဂံမြို့ရှိဂူဘုရားစဉ်သမိုင်းလင်္ကာ၌မဉ္ဇူဘုန်းတော်၊ သောင်း လုံးကျော်သည်၊ ထိပ်ပေါ်အထွတ်၊ရွှေနားညွတ်လော့၊ ရိမဒ်ပေါက္ကံ၊ တမ္ပဝတီ၊ သီရိပစ္စယာ၊ ပုဏ္ဏဂါမ၊ပုဂါမမည်၊ ဤငါးပြည်၌၊ ဆက်ရှည်စံပယ်၊ ငါးဆယ်နှင့်ငါး၊ နရဖျားတို့၊တည်ထားပြုစု၊ ကောင်းမှုစေ့မျိုး၊ကြဲစိုက်ပျိုးသည်၊ ပုထိုးစေတီ၊လက်ချောင်းစီသို့ရ၍ ဤဖွယ်တည့်၊ များစွာရှိလည်း၊ တွေ့မိသ၍၊ မစုံစေ့ခဲ့၊ ဘုန်းဟေ့နတ်လူ၊ဉာဏ်တံချူဖြင့်၊ ဆွတ်ယူစိမ့်ငှာ၊ထိပ်ချာတင်ရွက်၊ သီကုံးဆက်သည်၊ရွှေခွက်သောတာရုံဘုရားဟူ၍ဖြစ်သည်။

သမိုင်းမဝင်၊ စာမတင်
သမိုင်းမဝင်၊ စာမတင်၊ ရွာပင်မခေါ်ရ ဟူသော စကားတစ်ရပ် ရှိသည်။ မည်သည့်မြို့ မည်သည့်ရွာ ဖြစ်စေ သမိုင်း ခေါ် ဖြစ်စဉ်ကမူ ရှိမြဲဖြစ်သည်။ လူတို့က မသိ၍သာ မြုပ်ကွယ်နေမည်။ ဖြစ်စဉ်သမိုင်းကမူ ရွှံ့အိုင်အတွင်း၌ အနားယူနေသော ပတ္တမြား ရတနာသဖွယ် ဖြစ်ရာသည်။ 

သမိုင်း ဟူသော ဝေါဟာရကို မြန်မာဘာသာ စစ်စစ်ဟု ဆိုသူတို့က သမိုင်း (မိုင်း = ကြီးမား) သိဖွယ်ရာကြီး တစ်ရပ်ဟု အဓိပ္ပာယ်ဆိုသည်။ သမိုင်းဆိုလျင် သိရမည်။ သိအောင်ပြုရမည်ဟု ဆိုလိုသည်။ 

သမိုင်းကို ပါဠိဘာသာမှ ဆင်းသက်သည်ဟု ဆိုသူတို့က သမုတိ ဟူသော ပုဒ်မှလည်းကောင်း၊ သမ္မုတိ ဟူသော ပုဒ်မှလည်းကောင်း ဖြစ်သည်ဟု ဆို၏။ သမုတိမှ သံ - မညတေတိ၊ သမုတိ၊ သမ္မုတိမှ သမ္မနနံ-သမ္မုတိ ဟု ဝိဂြိုဟ် အသီးသီးဆိုကာ - သံပုဗ္ဗ မနဓာတ်ဖြင့် ကောင်းစွာသိခြင်းကိုချည်း ပြသည်။ သို့သော် သမိုင်းကို ပါဠိဘာသာမှ ဆင်းသက်ခြင်း မဟုတ်ဟု ယူဆကာ ပါဠိပညာရှင်များက သမုတိ၊ သမ္မုတိ များဖြင့် အဓိပ္ပာယ် မဖော်လိုကြပေ။ နာမည်ကျော် ပါဠိသက် အဘိဓာန်များကလည်း ယင်းကို လျစ်လျူရှုခဲ့ကြသည်။ 

သမိုင်းဟူသည် သိမှတ်ဖွယ်ရာ စာပေ, ကဗျာဖြစ်၍ မသိမဖြစ်၊ သိကိုသိရမည့်၊ မှတ်ကို မှတ်ရမည့် အကြောင်းအရာများပင် ဖြစ်သည်။ ဘုရားသမိုင်း၊ ကျောင်းသမိုင်း၊ မြို့သမိုင်း၊ ရွာသမိုင်း၊ လူ့သမိုင်း၊ အဖွဲ့အစည်းသမိုင်း၊ အသင်းအပင်းသမိုင်း၊ စာပေသမိုင်း စသည့် အဆောက်အအုံ မြို့ရွာ အရာဝတ္ထု အစုအစည်း အားလုံး၏ သိမှတ်ဖွယ်ရာ ရှေးအစူအစဉ်များပင် ဖြစ်ကြောင်း ထင်ရှားလှပါသည်။ ထို့ကြောင့် မြန်မာနိုင်ငံတွင် သမိုင်းဟူသည် မြန်မာစာပေ၌ အရေးကြီးသော အပိုင်းတစ်ပိုင်းအဖြစ် ပါဝင်လာရသည်။ မြန်မာစာပေအတွင်းမှ သမိုင်းဟူသည်ကို နုတ်လိုက်လျှင် လက်ကျန်အနည်းငယ်မျှသာ ကြွင်းကျန်လိမ့်မည်ဟု ယူဆရပေသည်။ သမိုင်းကိုလည်း မြန်မာစာပေမှ အဆီညှစ်၍ အနှစ်ကို ထုတ်ကာ ရွေးကောက်ရသည် ဖြစ်ရာ စာပေနှင့် သမိုင်းသည် မကင်းရာ မကင်းကြောင်းပင် ဖြစ်သည်။ 

သမိုင်းမဝင်၍ စာမတင်ခဲ့သလို၊ စာမတင်ခဲ့၍လည်း သမိုင်းဟူ၍ မဝင် မဖြစ်ပေါ်သည်လည်း ရှိသည်။ သမိုင်းဝင်ပါလျက် စာမတင်၍လည်း သမိုင်းအစပျောက်ကာ နောက်လူတို့ မသိမမြင်ကြရသည်ကလည်း ရှိပေသည်။ အမှန်အားဖြင့်ဆိုသော် ဤအချက်က ပို၍များ၏။ စာမတင်ခဲ့ရ၍ သမိုင်းမဖြစ်ခဲ့ရသည်မှာ မြန်မာနိုင်ငံတွင် ဒုနှင့်ဒေး အများအပြားဖြစ်၏။

ကိုးကား 

သမိုင်း
ပင်မ အကြောင်းအရာ ဆောင်းပါးများ

from __future__ import annotations

import re
import sys

import pytest

import click
from click._compat import _ansi_re
from click._compat import strip_ansi
from click._compat import term_len
from click._textwrap import _truncate_visible

ESC = "\033"

# Inventory of every escape sequence Click itself emits. ``strip_ansi`` must
# keep removing all of them.
CLICK_EMITTED = [
    # SGR foreground/background, the basic 16 colors.
    f"{ESC}[30m",
    f"{ESC}[37m",
    f"{ESC}[40m",
    f"{ESC}[47m",
    # SGR 256-color and true-color (Click renders these with semicolons).
    f"{ESC}[38;5;200m",
    f"{ESC}[48;5;91m",
    f"{ESC}[38;2;255;12;128m",
    f"{ESC}[48;2;135;0;175m",
    # SGR attributes and their resets.
    f"{ESC}[1m",
    f"{ESC}[22m",
    f"{ESC}[4m",
    f"{ESC}[24m",
    f"{ESC}[53m",
    f"{ESC}[55m",
    f"{ESC}[9m",
    f"{ESC}[29m",
    # Reset-all appended by style().
    f"{ESC}[0m",
    # Screen clear and cursor home from click.clear().
    f"{ESC}[2J",
    f"{ESC}[1;1H",
    # Cursor hide/show around the progress bar.
    f"{ESC}[?25l",
    f"{ESC}[?25h",
]

# CSI sequences Click never emits but may receive from other tooling.
CSI_FOREIGN = [
    # Colon-delimited (ISO 8613-6) true-color and 256-color SGR.
    f"{ESC}[38:2:255:0:0m",
    f"{ESC}[38:5:200m",
    f"{ESC}[1;38:2::255:0:0m",  # empty colon field is a valid parameter
    # SGR mouse reporting (the ``<`` parameter byte is 0x3C).
    f"{ESC}[<0;30;40M",
    f"{ESC}[<0;30;40m",
    # Private-mode set/reset with a multi-digit parameter.
    f"{ESC}[?1049h",
    f"{ESC}[?1049l",
    # Cursor-shape select: an intermediate byte (space, 0x20) before final ``q``.
    f"{ESC}[0 q",
    f"{ESC}[2 q",
    # Set scrolling region: a non-``m`` letter final byte.
    f"{ESC}[1;24r",
    # Function-key / bracketed-paste codes ending in ``~`` (0x7E).
    f"{ESC}[3~",
    f"{ESC}[200~",
    # Empty parameter list (``ESC [ m`` is a valid reset).
    f"{ESC}[m",
]

# The previous pattern, kept here to prove the new one is a superset.
_LEGACY_ANSI_RE = re.compile(r"\033\[[;?0-9]*[a-zA-Z]")


def test_is_jupyter_kernel_output():
    class JupyterKernelFakeStream:
        pass

    # implementation detail, aka cheapskate test
    JupyterKernelFakeStream.__module__ = "ipykernel.faked"
    assert click._compat._is_jupyter_kernel_output(stream=JupyterKernelFakeStream())


@pytest.mark.parametrize(
    "stream",
    [None, sys.stdin, sys.stderr, sys.stdout],
)
@pytest.mark.parametrize(
    ("color", "expected_override"),
    [
        (True, False),
        (False, True),
        (None, None),
    ],
)
@pytest.mark.parametrize(
    ("isatty", "is_jupyter", "expected"),
    [
        (True, False, False),
        (False, True, False),
        (False, False, True),
    ],
)
def test_should_strip_ansi(
    monkeypatch,
    stream,
    color: bool | None,
    expected_override: bool | None,
    isatty: bool,
    is_jupyter: bool,
    expected: bool,
) -> None:
    monkeypatch.setattr(click._compat, "isatty", lambda x: isatty)
    monkeypatch.setattr(
        click._compat, "_is_jupyter_kernel_output", lambda x: is_jupyter
    )

    if expected_override is not None:
        expected = expected_override
    assert click._compat.should_strip_ansi(stream=stream, color=color) == expected


@pytest.mark.parametrize("seq", CLICK_EMITTED + CSI_FOREIGN)
def test_strip_ansi_removes_full_sequence(seq):
    """Every complete CSI sequence is stripped, alone or wrapped in text."""
    assert strip_ansi(seq) == ""
    assert strip_ansi(f"a{seq}b") == "ab"
    assert term_len(f"a{seq}b") == 2


@pytest.mark.parametrize("final", ["m", "H", "J", "A", "z"])
@pytest.mark.parametrize("params", ["", "0", "1;2", ";", "?25", "0;0;0"])
def test_strip_ansi_is_superset_of_legacy(params, final):
    """Everything the legacy pattern stripped, the CSI grammar still strips."""
    seq = f"{ESC}[{params}{final}"
    assert _LEGACY_ANSI_RE.fullmatch(seq) is not None
    assert strip_ansi(seq) == ""
    assert strip_ansi(f"a{seq}b") == "ab"


@pytest.mark.parametrize(
    ("text", "expected"),
    [
        (f"{ESC}[31mred{ESC}[0m", "red"),
        (f"a{ESC}[38:2:1:2:3mb{ESC}[0mc", "abc"),
        (f"{ESC}[?25l{ESC}[2Jhidden{ESC}[?25h", "hidden"),
        (f"{ESC}[<0;1;1Mclick{ESC}[<0;1;1m", "click"),
        # Several adjacent sequences around each visible character.
        (f"{ESC}[1m{ESC}[31mA{ESC}[0m {ESC}[32mB{ESC}[0m", "A B"),
        # Real terminal captures ported from the boltons strip_ansi tests.
        # ANSI art fragment (its doctest example).
        (f"{ESC}[0m{ESC}[1;36mart{ESC}[46;34m\xdc", "art\xdc"),
        # `ls` color output, ending on a dangling SGR with no text after it.
        (
            f"ls\r\n{ESC}[00m{ESC}[01;31mfile.zip{ESC}[00m\r\n{ESC}[01;31m",
            "ls\r\nfile.zip\r\n",
        ),
        # Tab-separated colorized fields.
        (f"\t{ESC}[0;35mIP{ESC}[0m\t{ESC}[0;36m192.1.0.2{ESC}[0m", "\tIP\t192.1.0.2"),
        # A styled cell inside a box-drawing table.
        (
            f"╒══════╕\n│ {ESC}[1mCell{ESC}[0m │\n╘══════╛",
            "╒══════╕\n│ Cell │\n╘══════╛",
        ),
        # Kaomoji with a bolded run.
        (f"(╯°□°)╯︵ {ESC}[1m┻━┻{ESC}[0m", "(╯°□°)╯︵ ┻━┻"),
    ],
)
def test_strip_ansi_mixed_content(text, expected):
    assert strip_ansi(text) == expected
    assert term_len(text) == len(expected)


def test_strip_ansi_stops_at_final_byte():
    """The match ends at the first final byte."""
    assert strip_ansi(f"{ESC}[31mX{ESC}[0mY") == "XY"
    assert strip_ansi(f"{ESC}[1m{ESC}[31mZ") == "Z"
    # The final ``m`` ends the sequence; the following ``;1m`` is plain text.
    assert strip_ansi(f"{ESC}[m;1m") == ";1m"


@pytest.mark.parametrize(
    "text",
    [
        "",
        "plain text",
        "100% [done]",
        "array[0] = 1",
        "a;b;c",
        # Looks like SGR parameters but lacks the ESC introducer.
        "[38;5;200m not an escape",
        "[0m",
    ],
)
def test_strip_ansi_leaves_plain_text(text):
    """Text that merely resembles an escape sequence is never stripped."""
    assert strip_ansi(text) == text
    assert term_len(text) == len(text)


@pytest.mark.parametrize(
    "text",
    [
        f"{ESC}",  # lone ESC
        f"{ESC}[",  # CSI introducer with no final byte
        f"{ESC}[31",  # parameters but no final byte
        f"{ESC}[38:2:1",  # colon parameters, truncated
        f"{ESC}[0 ",  # intermediate byte but no final byte
    ],
)
def test_strip_ansi_leaves_incomplete_sequences(text):
    """An unterminated sequence (missing its final byte) is left untouched."""
    assert strip_ansi(text) == text


def test_strip_ansi_is_idempotent():
    text = f"{ESC}[38:2:1:2:3mhi{ESC}[0m {ESC}[<0;1;1mthere{ESC}[?25h"
    once = strip_ansi(text)
    assert once == "hi there"
    assert strip_ansi(once) == once


@pytest.mark.parametrize(
    ("text", "visible"),
    [
        ("", 0),
        ("plain", 5),
        (f"{ESC}[31mred{ESC}[0m", 3),
        (f"{ESC}[38;2;1;2;3mrgb{ESC}[0m", 3),
        (f"{ESC}[38:2:1:2:3mrgb{ESC}[0m", 3),
        (f"{ESC}[<0;1;1Mx{ESC}[<0;1;1m", 1),
        (f"{ESC}[0 qq", 1),
        (f"{ESC}[?25lvisible{ESC}[?25h", 7),
        (f"{ESC}[1m{ESC}[4m{ESC}[31mhello{ESC}[0m", 5),
    ],
)
def test_term_len(text, visible):
    assert term_len(text) == visible


@pytest.mark.parametrize("seq", CLICK_EMITTED + CSI_FOREIGN)
def test_ansi_re_matches_whole_sequence(seq):
    """``_ansi_re`` matches a complete sequence end to end as one token."""
    m = _ansi_re.match(seq)
    assert m is not None
    assert m.start() == 0
    assert m.end() == len(seq)


@pytest.mark.parametrize(
    ("text", "n", "expected"),
    [
        # No escapes: behaves like a plain prefix slice.
        ("abcdef", 3, "abc"),
        ("abc", 10, "abc"),
        ("abc", 0, ""),
        ("abc", -1, ""),
        # A leading escape is kept and does not count toward the budget.
        (f"{ESC}[31mabcdef{ESC}[0m", 3, f"{ESC}[31mabc"),
        # A colon true-color escape stays intact; the cut lands after 3 chars.
        (f"{ESC}[38:2:1:2:3mabcdef", 3, f"{ESC}[38:2:1:2:3mabc"),
        # A trailing escape past the cut is not pulled in.
        (f"{ESC}[31mabc{ESC}[0m", 3, f"{ESC}[31mabc"),
    ],
)
def test_truncate_visible(text, n, expected):
    out = _truncate_visible(text, n)
    assert out == expected
    assert term_len(out) <= max(n, 0)

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import os
import re
from cpt.packager import ConanMultiPackager
from cpt.ci_manager import CIManager
from cpt.printer import Printer


class BuilderSettings(object):
    @property
    def username(self):
        """ Set catchorg as package's owner
        """
        return os.getenv("CONAN_USERNAME", "catchorg")

    @property
    def login_username(self):
        """ Set Bintray login username
        """
        return os.getenv("CONAN_LOGIN_USERNAME", "horenmar")

    @property
    def upload(self):
        """ Set Catch2 repository to be used on upload.
            The upload server address could be customized by env var
            CONAN_UPLOAD. If not defined, the method will check the branch name.
            Only devel or CONAN_STABLE_BRANCH_PATTERN will be accepted.
            The devel branch will be pushed to testing channel, because it does
            not match the stable pattern. Otherwise it will upload to stable
            channel.
        """
        return os.getenv("CONAN_UPLOAD", "https://api.bintray.com/conan/catchorg/catch2")

    @property
    def upload_only_when_stable(self):
        """ Force to upload when running over tag branch
        """
        return os.getenv("CONAN_UPLOAD_ONLY_WHEN_STABLE", "True").lower() in ["true", "1", "yes"]

    @property
    def stable_branch_pattern(self):
        """ Only upload the package the branch name is like a tag
        """
        return os.getenv("CONAN_STABLE_BRANCH_PATTERN", r"v\d+\.\d+\.\d+")

    @property
    def reference(self):
        """ Read project version from branch create Conan reference
        """
        return os.getenv("CONAN_REFERENCE", "catch2/{}".format(self._version))

    @property
    def channel(self):
        """ Default Conan package channel when not stable
        """
        return os.getenv("CONAN_CHANNEL", "testing")

    @property
    def _version(self):
        """ Get version name from cmake file
        """
        pattern = re.compile(r"project\(Catch2 LANGUAGES CXX VERSION (\d+\.\d+\.\d+)\)")
        version = "latest"
        with open("CMakeLists.txt") as file:
            for line in file:
                result = pattern.search(line)
                if result:
                    version = result.group(1)
        return version

    @property
    def _branch(self):
        """ Get branch name from CI manager
        """
        printer = Printer(None)
        ci_manager = CIManager(printer)
        return ci_manager.get_branch()


if __name__ == "__main__":
    settings = BuilderSettings()
    builder = ConanMultiPackager(
        reference=settings.reference,
        channel=settings.channel,
        upload=settings.upload,
        upload_only_when_stable=False,
        stable_branch_pattern=settings.stable_branch_pattern,
        login_username=settings.login_username,
        username=settings.username,
        test_folder=os.path.join(".conan", "test_package"))
    builder.add()
    builder.run()

# Contributor Covenant Code of Conduct

## Our Pledge

In the interest of fostering an open and welcoming environment, we as contributors and maintainers pledge to making participation in our project and our community a harassment-free experience for everyone, regardless of age, body size, disability, ethnicity, gender identity and expression, level of experience, nationality, personal appearance, race, religion, or sexual identity and orientation.

## Our Standards

Examples of behavior that contributes to creating a positive environment include:

* Using welcoming and inclusive language
* Being respectful of differing viewpoints and experiences
* Gracefully accepting constructive criticism
* Focusing on what is best for the community
* Showing empathy towards other community members

Examples of unacceptable behavior by participants include:

* The use of sexualized language or imagery and unwelcome sexual attention or advances
* Trolling, insulting/derogatory comments, and personal or political attacks
* Public or private harassment
* Publishing others' private information, such as a physical or electronic address, without explicit permission
* Other conduct which could reasonably be considered inappropriate in a professional setting

## Our Responsibilities

Project maintainers are responsible for clarifying the standards of acceptable behavior and are expected to take appropriate and fair corrective action in response to any instances of unacceptable behavior.

Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct, or to ban temporarily or permanently any contributor for other behaviors that they deem inappropriate, threatening, offensive, or harmful.

## Scope

This Code of Conduct applies both within project spaces and in public spaces when an individual is representing the project or its community. Examples of representing a project or community include using an official project e-mail address, posting via an official social media account, or acting as an appointed representative at an online or offline event. Representation of a project may be further defined and clarified by project maintainers.

## Enforcement

Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by contacting the project team at github@philnash.me. The project team will review and investigate all complaints, and will respond in a way that it deems appropriate to the circumstances. The project team is obligated to maintain confidentiality with regard to the reporter of an incident. Further details of specific enforcement policies may be posted separately.

Project maintainers who do not follow or enforce the Code of Conduct in good faith may face temporary or permanent repercussions as determined by other members of the project's leadership.

## Attribution

This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4, available at [http://contributor-covenant.org/version/1/4][version]

[homepage]: http://contributor-covenant.org
[version]: http://contributor-covenant.org/version/1/4/

변형력(變形力) 또는 스트레스()은 역학에서 단위면적당 작용하는 힘을 뜻한다. 응력(應力)이라고도 한다. 오귀스탱 루이 코시가 1822년 처음 고안했다.

사실상 응력의 개념은 연속체(Continuum)라는 가정 아래 성립할 수 있다. 물체 내부의 경우, 가상의 단위부피를 설정해서 그 가상의 표면 바깥에 작용하는 힘을 계산하기 때문이다. 여기서 '가상의 힘'은 크게 두 종류가 있는데, 표면힘(Surface Force)과 몸체힘(Body Force)이다. 표면힘은 표면에 평행한 힘이며, 몸체힘은 표면에 대하여 수직 방향인 힘이다.

응력의 SI단위는 파스칼(Pa)이다. 압력과 같은 단위지만, 압력과 응력은 전혀 다른 개념이다.

일반적인 단면봉(Prismatic Bar)의 경우, 수직응력(Normal Stress)은 바깥쪽(Tension) 또는 안쪽(Compression)으로 작용한다. 변형률(Strain)과의 연관성 때문에, 보통 바깥쪽 응력을 양으로, 안쪽 응력을 음으로 본다. 이 경우, 보통은 계산의 편리성을 위해 모든 단면적에 고르게 힘이 작용한다라고 가정하고 평균값을 사용하는 경우가 많다. 즉,

실제로는 모든 지점마다 작용하는 응력의 값이 다르다. 때문에 코시는 이를 표현하기 위해 텐서를 사용했다.

이 방식은 축이 변할 경우 값이 어떻게 바뀌는지 계산하는 것이 힘들다는 단점을 가지고 있다. 이를 보완하기 위해 Mohr's Circle을 사용한다. 또한 코시 텐서는 작은 변형에 맞는 방식이기 때문에, 큰 변형의 경우 다른 방식을 사용한다.

응력 
응력(應力)은 물체가 외부 힘의 작용에 저항하여 원형을 지키려는 힘을 말하며 전단응력과 깊은 관계를 가지있으며 고체역학, 유체역학과도 연관있다. 한편 응력(凝力)은 원자, 분자 또는 이온 사이에 작용하여 고체나 액체 따위의 물체를 이루게 하는 서로 끌어당기는 힘을 통틀어 이르는 말로 응력(應力)과 연관있다.

같이 보기 

 연속체 역학

참고 

연속체역학
고전역학
텐서

ঢাকা বাংলাদেশের রাজধানী ও মহানগর বা বৃহত্তম শহর। প্রশাসনিকভাবে এটি ঢাকা বিভাগের ও জেলার প্রধান শহর। ভৌগোলিকভাবে এটি বাংলাদেশের মধ্যভাগে বুড়িগঙ্গা নদীর উত্তর তীরে একটি সমতল অঞ্চলে অবস্থিত। ঢাকা দক্ষিণ এশিয়ায় মুম্বাইয়ের পরে দ্বিতীয় বৃহৎ অর্থনৈতিক শহর। ঢাকার জিডিপি ১৬২ বিলিয়ন মার্কিন ডলার (২০২০)। এছাড়া ঢাকার পিপিপি ২৩৫ বিলিয়ন মার্কিন ডলার (২০২০)। ভৌগোলিকভাবে ঢাকা একটি অতিমহানগরী বা মেগাসিটি; ঢাকা মহানগরীর মোট জনসংখ্যা ৪ কোটি ৪২ লাখ ১৫ হাজার ১০৭ জন, যা দেশের মোট জনসংখ্যার প্রায় ১১ ভাগ। জনসংখ্যার বিচারে ঢাকা দক্ষিণ এশিয়ার দ্বিতীয় বৃহত্তম এবং বিশ্বের সপ্তম বৃহত্তম শহর। জনঘনত্বের বিচারে ঢাকা বিশ্বের সবচেয়ে ঘনবসতিপূর্ণ শহর; ৩০৬ বর্গকিলোমিটার আয়তনের এই শহরে প্রতি বর্গকিলোমিটার এলাকায় ২৩ হাজার লোক বাস করে।

ঢাকা শহর "মসজিদের শহর" নামেও সুপরিচিত। এখানে প্রায় দশ হাজারেরও বেশি মসজিদ আছে(ইসলামিক ফাউন্ডেশন বাংলাদেশ এর তথ্য মতে)। এই শহরে রোজ প্রায় ৫ লক্ষ রিকশা চলাচল করে। বর্তমানে ঢাকা দক্ষিণ এশিয়ার অন্যতম প্রধান সংস্কৃতি, শিক্ষা ও বাণিজ্যকেন্দ্র।

ঢাকা শহরের জলবায়ু ক্রান্তীয় আর্দ্র ও শুষ্ক প্রকৃতির। গড় তাপমাত্রা এপ্রিল মাসে সর্বোচ্চ প্রায় ৩৪ ডিগ্রী সেলসিয়াস এবং জানুয়ারি মাসে সর্বনিম্ন প্রায় ১৩ ডিগ্রি সেলসিয়াস। মে মাস থেকে সেপ্টেম্বর মাস পর্যন্ত এই অঞ্চলে বর্ষাকাল, সেসময় প্রতি মাসে গড়ে ৩০০ মিলিমিটারের বেশি বৃষ্টিপাত হয়।
 
সপ্তদশ শতাব্দীতে পুরান ঢাকা মুঘল সাম্রাজ্যের সুবা বাংলা (বাংলা প্রদেশ) এর প্রাদেশিক রাজধানী ছিল। মুঘল সম্রাট জাহাঙ্গীরের শাসনামলে এই শহর জাহাঙ্গীর নগর নামে পরিচিত ছিলো। বিশ্বব্যাপী মসলিন বাণিজ্যের একটি কেন্দ্র ছিলো ঢাকা এবং বিশ্বের বিভিন্ন স্থান থেকে ব্যবসায়ীগণ এখানে বাণিজ্যের উদ্দেশ্যে আসতেন। ঢাকাতে বিশ্বের সেরা মসলিন কাপড় উৎপাদিত হতো। যদিও আধুনিক ঢাকা শহরের বিকাশ ঘটে ঊনবিংশ শতাব্দীতে ব্রিটিশ শাসন আমলে, এই সময় নবাবগণ ঢাকা শাসন করতেন। এই সময় কলকাতার পরেই ঢাকা বাংলা প্রেসিডেন্সির দ্বিতীয় বৃহত্তম নগরী হয়ে ওঠে। ১৯০৫ সালের বঙ্গভঙ্গের পরে ঢাকা নবগঠিত পূর্ববঙ্গ ও আসাম প্রদেশের রাজধানী হয়। ১৯৪৭ সালে ভারত বিভাগের পরে ঢাকা পূর্ব পাকিস্তানের প্রশাসনিক রাজধানীতে পরিণত হয়। ১৯৫০-১৯৬০ সালের মধ্যে এই শহর বিভিন্ন সামাজিক, জাতীয়তাবাদী ও গণতন্ত্রপন্থী আন্দোলনের কেন্দ্রবিন্দু হয়ে ওঠে। ১৯৭১ সালে ঢাকা “স্বাধীন বাংলাদেশ রাষ্ট্রের রাজধানী” ঘোষিত হয়। ইতঃপূর্বে সামরিক আইন বলবৎ, বাংলাদেশের স্বাধীনতা ঘোষণা, সামরিক দমন, যুদ্ধ ও প্রাকৃতিক বিপর্যয়ের তাণ্ডবলীলার মতো একাধিক ঘটনার সাক্ষী হয় এই শহর।

বাংলাদেশের সংবিধানের ৫(ক) অনুচ্ছেদ অনুযায়ী ঢাকা বাংলাদেশের রাজধানী। আধুনিক ঢাকাকে বাংলাদেশের আপামর জনতা রাজনৈতিক, সাংস্কৃতিক ও অর্থনৈতিক জীবনের প্রধান কেন্দ্র  হিসেবে বিবেচনা করে। এটির প্রশংসিত জাতীয় দর্শনীয় স্থানগুলো যেমনঃ জাতীয় সংসদ ভবন, ঢাকা বিশ্ববিদ্যালয়, ঢাকা কলেজ,মুক্তিযুদ্ধ জাদুঘর, বাংলাদেশ জাতীয় জাদুঘর, লালবাগের কেল্লা, আহসান মঞ্জিল, হাতিরঝিল, জগন্নাথ বিশ্ববিদ্যালয়, জাহাঙ্গীরনগর বিশ্ববিদ্যালয়, জাতীয় স্মৃতিসৌধ, কেন্দ্রীয় শহীদ মিনার, বায়তুল মোকাররম মসজিদ, তারা মসজিদ, ঢাকেশ্বরী মন্দির, আর্মেনীয় গির্জা ইত্যাদি গুরুত্বপূর্ণ দর্শনীয় স্থান।

এই শহরের অবকাঠামো বিশ্বের মধ্যে উন্নত  হলেও দূষণ, যানজট এবং শহরমুখী মানুষের আধিক্যের কারণে জীবনমান উন্নয়নে ঋনাত্মক প্রভাব লক্ষ্যণীয়। সাম্প্রতিক দশকগুলিতে ঢাকার পরিবহন ও যোগাযোগ ব্যবস্থা, গণপূর্ত ব্যবস্থায় যে আধুনিকীকরণ হয়েছে, তা বিশেষভাবে লক্ষণীয়। বর্তমানে এই শহর প্রচুর বিদেশী বিনিয়োগ টানতে এবং ব্যবসা-বাণিজ্যের পরিধি বাড়াতে সক্ষম হয়েছে। সারা দেশ থেকে প্রচুর মানুষ ঢাকায় আসেন জীবন ও জীবিকার সন্ধানে। এ কারণে ঢাকা হয়ে উঠেছে বিশ্বের দ্রুততম ক্রমবর্ধমান নগরী, এই লক্ষ্য বাস্তবায়নে মালয়েশিয়া, জাপান, চীন, ভারত সহ বিভিন্ন দেশ অর্থ সহযোগিতা ও বিনিয়োগ করছে।

নামকরণের ইতিহাস 

ঢাকার নামকরণের সঠিক ইতিহাস নিয়ে ব্যাপক মতভেদ রয়েছে। কথিত আছে যে, সেন বংশের রাজা বল্লাল সেন বুড়িগঙ্গা নদীর তীরবর্তী এলাকায় ভ্রমণকালে সন্নিহিত জঙ্গলে হিন্দু দেবী দুর্গার একটি বিগ্রহ খুঁজে পান। দেবী দুর্গার প্রতি শ্রদ্ধাস্বরূপ রাজা বল্লাল সেন ঐ এলাকায় একটি মন্দির প্রতিষ্ঠা করেন। যেহেতু দেবীর বিগ্রহ ঢাকা বা গুপ্ত অবস্থায় খুঁজে পাওয়া গিয়েছিলো, তাই রাজা, মন্দিরের নাম রাখেন ঢাকেশ্বরী মন্দির। মন্দিরের নাম থেকেই কালক্রমে স্থানটির নাম ঢাকা হিসেবে গড়ে ওঠে।

আবার অনেক ঐতিহাসিকের মতে, মোঘল সম্রাট জাহাঙ্গীর যখন ঢাকাকে সুবাহ বাংলার রাজধানী হিসেবে ঘোষণা করেন; তখন সুবাদার ইসলাম খান আনন্দের বহিঃপ্রকাশস্বরূপ শহরে “ঢাক” বাজানোর নির্দেশ দেন। এই ঢাক বাজানোর কাহিনী লোকমুখে কিংবদন্তির রূপ নেয় এবং তা থেকেই শহরের নাম ঢাকা হয়ে যায়। এখানে উল্লেখ্য যে, মোঘল সাম্রাজ্যের বেশ কিছু সময় ঢাকা সম্রাট জাহাঙ্গীরের প্রতি সম্মান জানিয়ে জাহাঙ্গীরনগর নামে পরিচিত ছিলো।

ঢাকা নগরীকে বর্তমানে দু'ভাগে বিভক্ত করা হয়েছে - ঢাকা দক্ষিণ ও ঢাকা উত্তর। ঢাকা দক্ষিণই হলো পুরাতন মূল নগরী। ঢাকা উত্তর ঢাকার নবীন বর্ধিত উপশহরগুলো নিয়ে গঠিত।

ইতিহাস ও ঐতিহ্য 

ধারণা করা হয়, কালের পরিক্রমায় ঢাকা প্রথমে সমতট, পরে বঙ্গ ও গৌড় প্রভৃতি রাজ্যের অন্তর্ভুক্ত ছিলো। খ্রিষ্টীয় ১৩শ শতাব্দীর শেষের দিকে মুসলমানেরা ঢাকা দখল করে। মোঘল সম্রাট জাহাঙ্গীরের ফরমান অনুযায়ী ১৬ জুলাই ১৬১০ খ্রিষ্টাব্দে ঢাকাকে সুবাহ বাংলার রাজধানী ঘোষণা করা হয়। সম্রাট জাহাঙ্গীর-এর নাম অনুসারে রাজধানীর নাম জাহাঙ্গীরনগর রাখা হয়। সম্রাট জাহাঙ্গীরের জীবিতকাল পর্যন্ত এ নাম বজায় ছিলো।

এর আগে সম্রাট আকবরের আমলে বাংলা-বিহার-উড়িষ্যার প্রাদেশিক রাজধানী ছিলো বিহারের রাজমহল। সুবা বাংলায় তখন চলছিলো মোঘলবিরোধী স্বাধীন বারো ভূইঁয়াদের রাজত্ব। বারো ভূইয়ার নিয়ন্ত্রণ থেকে বাংলাকে করতলগত করতে ১৫৭৬ থেকে ১৬০৫ খ্রিষ্টাব্দ পর্যন্ত বারবার চেষ্টা চালানো হয়। এরপর সম্রাট জাহাঙ্গীরের শাসনামলে ১৬০৮ খ্রিষ্টাব্দে ইসলাম খান চিশতীকে রাজমহলের সুবেদার নিযুক্ত করেন। তিনি ১৬১০ খ্রিষ্টাব্দে বাংলার ভৌগোলিক অবস্থান বিবেচনা করে রাজধানী রাজমহল থেকে সরিয়ে ঢাকায় স্থানান্তর করেন।

সুবেদার ইসলাম খান চিশতী দায়িত্ব নেবার মাত্র পাঁচ বছরের মধ্যে বারো ভূঁইয়ার পতন ঘটে ও বর্তমান চট্টগ্রামের কিছু অংশ বাদে পুরো সুবে বাংলা মোগল সাম্রাজ্যের অধীনে চলে আসে।

১৬১০ খ্রিষ্টাব্দে ঢাকা সুবা বাংলার রাজধানী হলেও সুবাহ বাংলার রাজধানী বারবার পরিবর্তন করা হয়েছে। ১৬৫০ খ্রিষ্টাব্দে সুবেদার শাহ সুজা রাজধানী আবার রাজমহলে স্থানান্তর করেছিলেন। শাহ সুজার পতনের পর ১৬৬০ খ্রিষ্টাব্দে সুবেদার মীর জুমলা আবার রাজধানী ঢাকায় স্থানান্তর করেন। এরপর বেশ কিছুকাল ঢাকা নির্বিঘ্নে রাজধানীর মর্যাদা ভোগ করার পর ১৭১৭ খ্রিষ্টাব্দে সুবেদার মুর্শিদ কুলি খান রাজধানী মুর্শিদাবাদে স্থানান্তর করেন। এরপর ঢাকায় মোঘল শাসনামলে চলতো নায়েবে নাজিমদের শাসন, যা চলেছিল ১৭৯৩ সালে ব্রিটিশ শাসন শুরু হবার আগে পর্যন্ত। ব্রিটিশরা রাজধানী হিসেবে কলকাতাকে নির্বাচিত করলে ঢাকার গুরুত্ব আবারো কমতে থাকে।

এরপর দীর্ঘকাল পরে ১৯০৫ খ্রিষ্টাব্দে ঢাকা আবার তার গুরুত্ব ফিরে পায়। বঙ্গভঙ্গের পর ১৯০৫ সালে ঢাকাকে আসাম ও বাংলার রাজধানী করা হয়। কংগ্রেসের বাধার মুখে ব্রিটিশ রাজ আবার ১৯১১ সালে রাজধানী কলকাতায় ফিরিয়ে নেয়।

ভূগোল 

ঢাকা মধ্য বাংলাদেশে বুড়িগঙ্গা নদীর তীরে ২৩°৪২' থেকে ২৩°৫৪' উত্তর অক্ষাংশ এবং ৯০°২০' থেকে ৯০°২৮' পূর্ব দ্রাঘিমাংশ পর্যন্ত বিস্তৃত। নিম্ন গাঙ্গেয় সমভূমিতে অবস্থিত এই শহরের মোট আয়তন । ঢাকায় মোট ৪৬ টি থানা আছে। এগুলো হলো - চকবাজার, লালবাগ, কোতোয়ালি, সূত্রাপুর, হাজারীবাগ, রমনা, মতিঝিল, পল্টন, ধানমণ্ডি, মোহাম্মদপুর, তেজগাঁও, গুলশান, মিরপুর, পল্লবী, শাহ আলী, তুরাগ,খিলক্ষেত, সবুজবাগ, ঢাকা ক্যান্টনমেন্ট, ডেমরা, শ্যামপুর, বাড্ডা, কাফরুল, কামরাঙ্গীর চর, খিলগাঁও ও উত্তরা। ঢাকা শহরটি মোট ১৩০টি ওয়ার্ড ও ৭২৫টি মহল্লায় বিভক্ত। ঢাকা জেলার আয়তন ১৪৬৩.৬০ বর্গ কিলোমিটার (৫৬৫ বর্গমাইল)। এই জেলাটি গাজীপুর, টাঙ্গাইল, মুন্সীগঞ্জ, রাজবাড়ী, নারায়ণগঞ্জ ও মানিকগঞ্জ জেলা দ্বারা বেষ্টিত।

ক্রান্তীয় বৃক্ষ, আর্দ্র মৃত্তিকা ও সমুদ্রপৃষ্ঠের সঙ্গে সমান সমতলভূমি এই জেলার বৈশিষ্ট্য। এই কারণে বর্ষাকালে ও প্রাকৃতিক দুর্যোগের সময় ঢাকা জেলায় প্রায়শই বন্যা দেখা যায়।

আবহাওয়া ও জলবায়ু 
ঢাকার জলবায়ু প্রধানত উষ্ণ, বর্ষণমুখর এবং আর্দ্র গ্রীষ্মমন্ডলীয়। কোপেন জলবায়ু শ্রেণীবিভাগ এর অধীনে, ঢাকার জলবায়ু ক্রান্তীয় সাভানা জলবায়ু। এই শহরের একটি স্বতন্ত্র মৌসুম রয়েছে, এখানে বার্ষিক গড় তাপমাত্রা ২৭.৫ ডিগ্রি সেলসিয়াস(৮১.৫ ডিগ্রি ফারেনহাইট) এবং জানুয়ারি থেকে এপ্রিল মাসের মধ্যে তাপমাত্রা ১৯.৫ থেকে ৩২ ডিগ্রি সেলসিয়াসের(৬৭ থেকে ৯০ ডিগ্রি ফারেনহাইট) মধ্যে থাকে। মে থেকে অক্টোবর মাসের মধ্যে গড়ে প্রায় ২১২১ মিলিমিটার(৮৩.৫ ইঞ্চি) বৃষ্টিপাত হয়ে থাকে, যা সারাবছরের মোট বৃষ্টিপাতের প্রায় ৮৭%। যানজট এবং এবং শিল্প কারখানার অপরিকল্পিত বর্জ্য নির্গমনের ফলে প্রতিনিয়ত বায়ু এবং পানি দূষণ বাড়ছে, ফলে শহরের জনস্বাস্থ্য এবং জীবন মান মারাত্বকভাবে প্রভাবিত হচ্ছে। ঢাকার চারপাশে জলাশয় এবং জলাভূমি গুলি ধ্বংসের সম্মুখীন কারণ, এগুলো ভরাট হয়ে যাচ্ছে বহুতল ভবন এবং অন্যান্য আবাসন উন্নয়ন প্রকল্পের মাধ্যমে। দূষণের ফলে প্রকৃতির যে ক্ষতি হচ্ছে তার ফলে এই এলাকার জীববৈচিত্র্য হুমকির সম্মুখীন। যদিও বর্তমানে ঢাকাকে বসবাস উপযোগী করার বিভিন্ন পদক্ষেপ গ্রহণ করা হচ্ছে।

স্থানীয় সরকার 

ঢাকা পৌরসভা প্রতিষ্ঠিত হয়েছিল ১ আগস্ট, ১৮৬৪ সালে এবং পরবর্তীকালে ১৯৭৮ সালে এটি "কর্পোরেশন"-এ উন্নীত করা হয়। ঢাকা উত্তর সিটি কর্পোরেশন ও ঢাকা দক্ষিণ সিটি কর্পোরেশন নামের ২ টি স্ব-শাসিত সংস্থা ঢাকা শহরের পরিচালনের দায়িত্বে নিয়োজিত রয়েছে। এই শহর অনেকগুলি প্রশাসনিক ওয়ার্ডে বিভক্ত এবং প্রতিটি ওয়ার্ডে একজন কমিশনার দায়িত্বপ্রাপ্ত আছেন। প্রতি ৫ বছর পরপর সরাসরি ভোটের মাধ্যমে উভয় সিটি কর্পোরেশনে একজন করে মেয়র নির্বাচন করা হয়, যিনি প্রতিষ্ঠানের কার্যনির্বাহী প্রধান হিসাবে কাজ করেন। ওয়ার্ড কমিশনারও ৫ বছরের জন্য সরাসরি ভোটের মাধ্যমে নির্বাচিত হন। এছাড়াও মহিলাদের জন্য ঢাকা সিটি কর্পোরেশনে ৩০টি সংরক্ষিত কমিশনার পদ রয়েছে। ঢাকা শিক্ষা বোর্ড সকল সরকারি স্কুল এবং অধিকাংশ বেসরকারি স্কুলের প্রশাসনিক দায়িত্বে রয়েছে। তবে মাদ্রাসা এবং ইংরেজি মাধ্যমের স্কুলসমূহ এই বোর্ডের অন্তর্ভুক্ত নয়। বাংলাদেশের সকল মাদ্রাসা একটি কেন্দ্রীয় বোর্ডের মাধ্যমে এবং ইংরেজি মাধ্যমের স্কুল সমূহ একটি পৃথক শিক্ষাবোর্ড এবং প্রশাসনিক কাঠামোর অধিনে পরিচালিত হয়।

ঢাকা মেট্রোপলিটন পুলিশ (ডিএমপি) ১৯৭৬ সালে প্রতিষ্ঠিত হয়। মোট ১২টি পুলিশ স্টেশনে প্রায় ৬০০০ এরও বেশি পুলিশ সদস্য ছিলেন। শহরের জনসংখ্যা ব্যাপকভাবে বৃদ্ধি পাওয়ায় পুলিশবাহিনীতে সদস্য সংখ্যা ৩৪০০০ এ উন্নীত করা হয়, এবং এর কার্যক্রম পরিচালনা করা হয় ৫০টি পুলিশ স্টেশন রয়েছে।

ঢাকা শহর ২৫টি সংসদীয় এলাকায় বিভক্ত। এখানে প্রধান দুই রাজনৈতিক দল হল আওয়ামী লীগ এবং বাংলাদেশ জাতীয়তাবাদী দল। রমনায় সচিবালয় অবস্থিত এবং এখানেই সরকারের প্রায় সকল মন্ত্রণালয় রয়েছে। বাংলাদেশ সুপ্রীম কোর্ট এবং ঢাকা হাই কোর্ট এই শহরে অবস্থিত। বঙ্গভবন ভারতের গভর্নর-জেনারেল ও পূর্ব পাকিস্তান গভর্নর এর বাসভবন হিসেবে ব্যবহার হতো এবং বর্তমানে বাংলাদেশের রাষ্ট্রপতির বাসভবন হিসাবে ব্যবহৃত হচ্ছে। জাতীয় সংসদ ভবন বাংলাদেশ সরকারের এক কক্ষ বিশিষ্ট সংসদ কার্যক্রমের কাজে ব্যবহৃত হয়। খ্যাতনামা স্থপতি লুইস কান এই জাতীয় সংসদ ভবনের স্থপতি ছিলেন।বায়তুল মুকাররম এদেশের জাতীয় মসজিদ, মক্কার কাবা শরিফের নকশায় অনুপ্রাণিত হয়ে এই মসজিদের ডিজাইন করা হয়েছে। এই শহরের অন্যান্য ঐতিহাসিক স্থান সমূহের মধ্যে রয়েছে বড় কাটরা, লালবাগ কেল্লা, হোসেনী দালান, আহসান মঞ্জিল, বাহাদুর শাহ পার্ক, জগন্নাথ বিশ্ববিদ্যালয়, ইত্যাদি।

ঢাকায় একটি কেন্দ্রীয় পানি নিষ্কাশন ব্যবস্থা থাকলেও মোট জনসংখ্যার মাত্র ২৫% এই ব্যবস্থার আওতাভুক্ত, এর পাশাপাশি আরও ৩০% এই সুবিধা ব্যবহার করে সেপটিক ট্যাংকের মাধ্যমে। মাত্র দুই তৃতীয়াংশ লোক শহরে সরবরাহকৃত পানি ব্যবহার করতে পারে। এখানে প্রতি বছর ৯৭ লক্ষ টন কঠিন বর্জ্য উৎপন্ন হয়। সরকারি এবং বেসরকারি ব্যবস্থাপনার মাধ্যমে সফলতার সাথে এই বর্জ্য ব্যবস্থাপনার কাজ করা হয়ে থাকে। কেন্দ্রীয়ভাবে এই বর্জ্য ব্যবস্থাপনার জন্য বেশ কয়েকটি স্থান রয়েছে, তবে অনেক ক্ষেত্রেই এগুলো কাছাকাছি নিচু এলাকায় অথবা জলাশয়ে ফেলা হয়ে থাকে।

পৌর প্রশাসন 

ঢাকা পৌরসভা ১৮৬৪ সালের ১ই আগস্ট প্রতিষ্ঠিত হয়েছিল, এবং ১৯৭৮ সালে কর্পোরেশন অবস্থা উন্নীত হয়েছে। ঢাকা সিটি কর্পোরেশনের একটি স্বায়ত্ত কর্পোরেশন যা শহর বিষয়াবলি চালায় (অর্থাত ২০১১ সাল থেকে), ঢাকা সিটি করপোরেশন বর্তমানে দুই প্রশাসনিক অংশে বিভক্ত করা হয়েছে – এইগুলো হলো (১) ঢাকা উত্তর সিটি কর্পোরেশন এবং (২) ঢাকা দক্ষিণ সিটি কর্পোরেশন – ভাল নাগরিক সুবিধা নিশ্চিত করার জন্য। এই দুটি কর্পোরেশন প্রশাসকদের দ্বারা চালিত হয়। অন্তর্ভুক্ত এলাকায়গুলো কয়েকটি পৌরসভায় বিভক্ত করা হয়েছে, যা কমিশনার নির্বাচিত করেছেন। ঢাকা শিক্ষা বোর্ডের দায়িত্ব ও নির্দেশ অনুযায়ী সমস্ত সরকারি স্কুল এবং অধিকাংশ বেসরকারি স্কুলগুলো চালানো হয়, শুধুমাত্র ইংরেজি মাধ্যম স্কুলগুলো এবং মাদ্রাসাগুলো ছাড়া। বাংলাদেশে সকল মাদ্রাসা একটি কেন্দ্রীয় বোর্ড দ্বারা পরিচালিত যখন ইংরেজি মাধ্যম স্কুলগুলো পৃথক শিক্ষা ও শাসন কাঠামোর অধীনে হয়ে থাকে।

ঢাকা মেট্রোপলিটন পুলিশ ১৯৭৬ সালে প্রতিষ্ঠিত হয়। সেইসময় ৬,০০০ পুলিশ-বাহিনী মোট ১২টি পুলিশ থানায় কর্মরত ছিল। শহর দ্রুত বৃদ্ধির সঙ্গে সঙ্গে, বর্তমানে পুলিশ-বাহিনী উত্থাপিত হয়েছে প্রায় ৩৪০০০ জনে এবং ৫০টি পুলিশ থানা স্থাপনের কাজ সম্পন্ন হয়েছে।

ক্রমবর্ধমান যানজট এবং জনসংখ্যা সমস্যার মোকাবিলায় জাতীয় সরকার সম্প্রতি পার্শ্ববর্তী এলাকার দ্রুত নগরায়নের একটি নীতি বাস্তবায়ন করেছে। ঢাকা মহানগরীকে কেন্দ্র করে বিশেষত বর্তমানে দ্রুত জনবিস্ফোরণের যে পরিস্থিতি সৃষ্টি হয়েছে, তাতে আশঙ্কা করা হচ্ছে যে ২০৩৫ সালের মধ্যে নগরীর জনসংখ্যা ৩ কোটিকেও ছুঁয়ে ফেলতে পারে। ফলে স্বাভাবিক নাগরিক পরিষেবা ভেঙে পড়ার উপক্রম হবে। তাই ঢাকা শহরকে ঘিরে একদিকে বর্তমানে বিভিন্ন উপনগরীর প্রবর্তন করে ও অন্যদিকে সমগ্র দেশ জুড়েই দারিদ্রের যথাসাধ্য মোকাবিলা করে নগরমুখী লাগামছাড়া জনস্রোতকে কিছুটা মোকাবিলা করাই এই পরিকল্পনার লক্ষ্য।

প্রশাসনিক সংস্থা 

ঢাকা বিশ্বের অন্যান্য মেগা শহরগুলো থেকে ভিন্ন, ঢাকা বিভিন্ন মন্ত্রণালয়ের অধীনে চার বার সরকার প্রতিষ্ঠানের দ্বারা সেবা নিয়েছে। দুই কর্পোরেশন, উত্তর এবং দক্ষিণ, দুই ক্ষমতাহীন মেয়রদের নেতৃত্বে চালিত হয় যখন তাদের ওপর কোনো নিয়ন্ত্রণ ছিল না। তাছাড়া, তাদের মধ্যে সমন্বয়ের অভাব এবং বাংলাদেশ সরকার কর্তৃক সকল ক্ষমতার কেন্দ্রীভবন, একটি বিশৃঙ্খল পরিস্থিতি উন্নয়ন এবং তারা শহর রক্ষণাবেক্ষণ চালিয়ে যায়।

পানি ব্যবস্থাপনা
ঢাকায় একটি জলবাহিত নিকাশী ব্যবস্থা রয়েছে, কিন্তু ঢাকার জনসংখ্যার মাত্র ১৫% এই সেবা পায় এবং অপরদিকে ৩০% সেপটিক ট্যাংক সেবা পায়।

অর্থনীতি 

ঢাকা শহরের প্রকৃত নমিনাল জিডিপি ১৬২ বিলিয়ান মার্কিন ডলার এবং শহরের পিপিপি প্রায় ২৩৫ বিলিয়ন মার্কিন ডলার। ঢাকা বাংলাদেশের প্রধান বাণিজ্যিক কেন্দ্র। শহরে উঠতি মধ্যবিত্ত জনসংখ্যা বাড়ছে ঢাকা পাশাপাশি আধুনিক ভোক্তা এবং বিলাস পণ্যের বাজার বৃদ্ধি পাচ্ছে। ঐতিহাসিকভাবেই এই শহরে অভিবাসী শ্রমিকদের আকৃষ্ট করে আসছে। হকার, ছোটো দোকান, রিকশা, রাস্তার ধারের দোকান শহরের মোট জনসংখ্যার একটি বিরাট অংশ। শুধুমাত্র রিকশা চালকের সংখ্যাই ৫ লাখ এর বেশি। কর্মপ্রবাহের প্রায় অর্ধেকই গৃহস্থালি অথবা অপরিকল্পিত শ্রমজীবী হিসাবে কর্মরত আছেন। যদিও টেক্সটাইল শিল্পে প্রায় ৮০০,০০০ এরও বেশি মানুষ কাজ করছেন। তারপরও এখানে বেকারত্বের হার ছিলো প্রায় ১৯%। ২০১৯ সালের হিসাব অনুযায়ী ঢাকা শহরের স্থাবর সম্পদের মূল্য প্রায় ১৪২ বিলিয়ন ডলার। যার প্রবৃদ্ধি ৬.৪%। ঢাকার বার্ষিক মাথাপিছু আয় ১৩০০ মার্কিন ডলার এবং এখানে প্রায় ১৫% মানুষ দারিদ্র্য সীমার নিচে বসবাস করে। এই জনসংখ্যার একটি বড় অংশ কর্মসংস্থানের সন্ধানে গ্রাম থেকে শহরে এসেছে এবং এদের অনেকেরই দৈনিক আয় ৫ মার্কিন ডলারের কম।

শহরের প্রধান বাণিজ্যিক এলাকাগুলো হলো মতিঝিল, চকবাজার, নবাবপুর, নিউ মার্কেট, ফার্মগেট ইত্যাদি এবং প্রধান শিল্প এলাকা গুলো হল তেজগাঁও, হাজারীবাগ ও লালবাগ। বসুন্ধরা-বারিধারা একটি উন্নয়নশীল অর্থনৈতিক এলাকা এবং আগামী ৫ বছরের মধ্যে এই এলাকায় উচ্চ প্রযুক্তির শিল্পকারখানা, কর্পোরেশন এবং শপিং মল তৈরী করা হবে। ঢাকা রপ্তানি প্রক্রিয়াজাতকরণ অঞ্চল প্রধানত গার্মেন্টস, টেক্সটাইল এবং অন্যান্য পণ্য রপ্তানিতে উদ্বুদ্ধ করর লক্ষ্যে তৈরী করা হয়েছিল। ঢাকায় মোট দুটি ইপিজেড-এ মোট ৪১৩টি শিল্প স্থাপনা রয়েছে। এখানকার অধিকাংশ কর্মীই নারী। এই শহরের ঢাকা স্টক এক্সচেঞ্জ দেশের অন্যতম বৃহত স্টক এক্সচেঞ্জ, এখানে তালিকাভুক্ত বৃহত্তম আন্তর্জাতিক প্রতিষ্ঠানগুলোর মধ্যে রয়েছে সিটিগ্রুপ, এইচএসবিসি ব্যাঙ্ক বাংলাদেশ, জেপি মর্গান চেজ, স্ট্যান্ডার্ড চার্টার্ড ব্যাঙ্ক (বাংলাদেশ), আমেরিকান এক্সপ্রেস, শেভরন, এক্সন মবিল, টোটাল, ব্রিটিশ পেট্রোলিয়াম, ইউনিলিভার, নেসলে, ডিএইচএল, ফেডএক্স, ব্রিটিশ আমেরিকান টোবাকো ইত্যাদি। স্থানীয় বড় আকারের শিল্পগ্রুপ যেমন কনকর্ড গ্রুপ, র‌্যাংগস গ্রুপ, বেক্সিমকো গ্রুপ, টি কে শিল্প গ্রুপ, সামিট গ্রুপ, নাভানা গ্রুপ, জামান গ্রুপ অব ইন্ডাস্ট্রিজ, রহিম আফরোজ ইত্যাদি প্রতিষ্টানের প্রধান বাণিজ্যিক কার্যালয় ঢাকায় অবস্থিত। এই শহরেই নোবেল পুরস্কার প্রাপ্ত প্রতিষ্ঠান গ্রামীণ ব্যাংক, ব্র্যাক এবং বাংলাদেশের প্রথম ভূমি উন্নয়ন ব্যাংক প্রগতি কো-অপারেটিভ ল্যান্ড ডেভেলপমেন্ট ব্যাংক লিমিটেড (প্রগতি ব্যাংক) এর প্রধান কার্যালয় ঢাকা বিভাগেই অবস্থিত। নগরায়নের মাধ্যমে ব্যাপকভাবে শহরের উন্নয়ন চলছে, নতুন নতুন বহুতল ভবন তৈরী হচ্ছে ফলে খুব অল্প সময়ের মধ্যেই শহরের পরিবর্তন হয়েছে। ফাইন্যান্স, ব্যাংকিং, শিল্পোৎপাদন, টেলিযোগাযোগ এবং সেবা খাতে বিশেষভাবে উন্নয়ন হচ্ছে। পাশাপাশি শহরের অর্থনৈতিক উন্নয়নের জন্য পর্যটন এবং হোটেল রেস্তোরাঁর উন্নয়নও সমান গুরুত্বপূর্ণ।

পরিবহন 

 

ঢাকা বিশ্বের মধ্যে রিকশার রাজধানী নামে পরিচিত। প্রতিদিন গড়ে এখানে প্রায় ৪,০০,০০০ রিকশা চলাচল করে।

রিকশা এবং ইঞ্জিন চালিত অটো রিকশা ঢাকার অন্যতম প্রধান বাহন, আর এই শহরে যে প্রায় ৪০০০০০০ এর বেশি রিকশা চলাচল করে, তা অন্য সকল দেশের মধ্যে সর্বোচ্চ যদিও সরকারি হিসাব মতে ঢাকা শহরের জন্য মোট ৮৫,০০০ রিকশার নিবন্ধন দেয়া হয়েছে। রিকশা ঢাকা শহরের রাস্তার যানজটের অন্যতম কারণ এবং কিছু বড় বড় রাস্তায় রিকশা চলাচল বন্ধ করে দেওয়া হয়েছে।

সরকারি সংস্থা বাংলাদেশ সড়ক পরিবহন কর্পোরেশন পরিচালিত বাস ঢাকা শহরের পরিবহনের আরেকটি জনপ্রিয় উপায়। এছাড়া রয়েছে বহু বেসরকারি বাস সার্ভিস। ২০০২ খ্রিষ্টাব্দের পর থেকে ঢাকা শহরে পেট্রোল ও ডিজেলচালিত কিছু যানবাহন (বেবি ট্যাক্সি, টেম্পো ইত্যাদি) বন্ধ করে দেওয়া হয় ও পরিবর্তে প্রাকৃতিক গ্যাস (Compressed Natural Gas – CNG) বা সিএনজিচালিত সবুজ অটোরিক্সা চালু হয়। এর ফলে পরিবেশ দূষণ অনেক কমে এসেছে।

স্কুটার, ট্যাক্সি এবং ব্যক্তিগত মালিকানাধীন যানবাহনগুলো শহরের মধ্যবিত্ত শ্রেণীর মধ্যে খুব দ্রুত জনপ্রিয় হয়ে উঠছে সরকার দুই স্ট্রোক ইঞ্জিন বিশিষ্ট অটো রিকশার প্রতিস্থাপন করে "সবুজ অটোরিকশা" চালু করেছে যা সিএনজি অটোরিকশার বা বেবি-ট্যাক্সি নামে পরিচিত এগুলোতে পরিবেশ বান্ধব সংকুচিত প্রাকৃতিক গ্যাস ব্যবহার করা হয়। ঢাকা রাস্তা চলাচলকারী ট্যাক্সিগুলো দুই ধরনের হয়। হলুদ ট্যাক্সিগুলো কিছুটা উচ্চ মান সম্পন্ন হয়ে থাকে যদিও এটি ব্যয়বহুল। এই ট্যাক্সিগুলো শীতাতপ নিয়ন্ত্রিত; টয়োটা করোলা এর, টয়োটা প্রিমিও এর এবং টয়োটা এলিয়ন মডেলের গাড়িগুলো ট্যক্সি হিসাবে ব্যবহার করা হয় এখানে। ২০১৩ সালে এই সেবাটি প্রথমে ২০০-২৫০০ টি ট্যক্সি নিয়ে শুরু করা হয়েছিলো। সরকার ১,৫০০সিসি ক্ষমতা বিশিষ্ট ইঞ্জিনের আরও ৫,০০০ নতুন ট্যাক্সি আমদানি করার সিদ্ধান্ত নিয়েছে। সরকারের পক্ষ থেকে বলা হয়েছে এই ধরনের ট্যাক্সির সংখ্যা ১৮,০০০ পর্যন্ত বাড়ানো হবে।

, ঢাকার  রাস্তাগুলো বাঁধানো ছিলো। সড়কপথ, রেলপথের মাধ্যমে ঢাকা শহর দেশের অন্যন্য অংশের সাথে সংযুক্ত আছে। ঢাকা থেকে ভারতের কলকাতা ও আগরতলা ​​শহরে যাতায়াতের জন্য বিআরটিসি পরিচালিত নিয়মিত বাস সার্ভিস রয়েছে।

ঢাকার রেলওয়ে স্টেশনগুলোর মধ্যে রয়েছে কমলাপুর রেলওয়ে স্টেশন, বিমানবন্দর রেলওয়ে স্টেশনে, বনানী রেলওয়ে স্টেশনে, তেজগাঁও রেলওয়ে স্টেশন, ক্যান্টনমেন্ট রেলওয়ে স্টেশনে এবং গেন্ডারিয়া রেলওয়ে স্টেশন, রাষ্ট্র পরিচালিত বাংলাদেশ রেলওয়ে শহরতলি এবং জাতীয় রুটে সেবা প্রদান করে থাকে। বাংলাদেশ রেলওয়ের ঢাকা ও কলকাতার মধ্যে একটি নিয়মিত আন্তর্জাতিক ট্রেন সার্ভিস পরিচালনা করে থাকে। ঢাকা থেকে অন্যান্য শহরতলি এলাকায় রেল যোগাযোগ রয়েছে, নারায়ণগঞ্জ ও গাজীপুরে ডেমু (DEMU) ট্রেনের মাধ্যমে নিয়মিত রেলসেবা পরিচালনা করে আসছে বাংলাদেশ রেলওয়ে।

বুড়িগঙ্গা নদীর তীরে সদরঘাট নৌবন্দরের মাধ্যমে নদীর অপর পারে এবং বাংলাদেশের অন্যান্য বিভিন্ন স্থানে যাত্রী এবং মালপত্র পরিবহন করা হয়।

হযরত শাহজালাল আন্তর্জাতিক বিমানবন্দর, ঢাকা শহরের কেন্দ্রে থেকে মাত্র ১৫ কিলোমিটার উত্তরে অবস্থিত, এটি দেশের বৃহত্তম এবং ব্যস্ততম বিমানবন্দর। দেশের মোট বিমান আগমন এবং প্রস্থানের ৫২% পরিচালনা করা হয় এখানে। চট্টগ্রাম, সিলেট, রাজশাহী, কক্সবাজার, যশোর, বরিশাল, সৈয়দপুরে অভ্যন্তরীণ সেবা এবং এশিয়া, মধ্যপ্রাচ্য এবং পশ্চিম ইউরোপের প্রধান শহরগুলোতে আন্তর্জাতিক সেবাপরিচালনা করা হয়।

নাগরিক পরিষেবা 
ঢাকায় নাগরিক পরিষেবা প্রদানের জন্য বিভিন্ন সেবামূলক প্রতিষ্ঠান কাজ করে থাকে। ঢাকা শহরের পানি চাহিদা পূরণের জন্য ঢাকা ওয়াসা, বিদ্যুৎ সঞ্চালন লাইন বা বিদ্যুৎ সরবরাহ করার জন্য ডেসা এবং ডেসকো, গ্যাস সরবারহ করার জন্য তিতাস গ্যাস প্রভৃতি সেবামূলক সংস্থা নিয়োজিত রয়েছে।

জনগোষ্ঠী 

ঢাকা বাংলাদেশের সবচেয়ে বড় শহর যা বাঙালি সংস্কৃতির একটি ছবিও বলা চলে। ঢাকায় বসবাসকারীদের কিছু অংশের পূর্বপুরুষরা ভারতীয়। তারা অনেকেই ১৯৪৭ খ্রিষ্টাব্দে দেশ বিভাগের সময় ভারত থেকে এসেছিলেন। এদের মধ্যে কিছু বিহারী মুসলমানও ছিলেন। এদের সংখ্যা বর্তমানে কয়েক লক্ষ। এখানকার বেশিরভাগ লোক মুসলমান সম্প্রদায়ের, এদের সংখ্যা শতকরা ৮৫%। কিন্তু সাথে বহু হিন্দু সম্প্রদায়ের বাস এই শহরে যারা জনসংখ্যায় দ্বিতীয় অবস্থানে রয়েছে শতকরা ১০%। এছাড়াও  খ্রিস্টান, বৌদ্ধ এবং শিখ ধর্মাবলম্বী সম্প্রদায়ের লোক বসবাস করেন। ক্ষুদ্রনৃগোষ্ঠীর মাঝে হরিজন, ঋষি ও বাহাই সম্প্রদায়ের লোক বসবাস করে। ঢাকায় বসবাসকারী প্রায় সবাই বাংলা ভাষায় কথা বলেন, পুরান ঢাকা'র লোকেরা উর্দুতেও কথা বলে থাকেন। বর্তমানে নতুন প্রজন্মের অনেকেই ইংরেজি ভাষা ব্যবহার করে। ঢাকা নগরী অনেকগুলো ইংলিশ মিডিয়াম স্কুল আছে যারা ইংরেজি ভাষাকে শিক্ষার মাধ্যম হিসেবে ব্যবহার করে। কিছু ক্ষুদ্রনৃগোষ্ঠীরা হিন্দি, তামিল, তেলুগু ও ভোজপুরী ভাষাও ব্যবহার করে।

পুরান ঢাকার স্থানীয় আদি অধিবাসীদের 'ঢাকাইয়া' বলা হয়। তাদের আলাদা উপভাষা এবং সংস্কৃতি রয়েছে। ঢাকা রাজধানী হওয়ায় সারা বাংলাদেশ থেকেই এখানে লোকজন উন্নত জীবনযাপনের উদ্দেশ্যে আসে।

সংস্কৃতি 

ঢাকা বিশ্ববিদ্যালয় ও জগন্নাথ বিশ্ববিদ্যালয়, কে মূল ধরে তার পার্শ্ববর্তী এলাকা হচ্ছে ঢাকা শহরের সাংস্কৃতিক কেন্দ্র। ঢাকা বিশ্ববিদ্যালয়, জগন্নাথ বিশ্ববিদ্যালয় বাংলা একাডেমি, চারুকলা ইনস্টিটিউট, কেন্দ্রীয় গণ গ্রন্থাগার ও জাতীয় জাদুঘর এলাকা সংস্কৃতি-কর্মীদের চর্চা ও সাংস্কৃতিক প্রদর্শনীর মূল ক্ষেত্র। এর বাইরে বেইলি রোডকে নাটকপাড়া বলা হয় সেখানকার নাট্যমঞ্চগুলোর জন্য। এছাড়াও নবনির্মিত শিল্পকলা একাডেমির এক্সপেরিমেন্টাল থিয়েটার হল এবং অন্যান্য মঞ্চসমূহ নাট্য ও সঙ্গীত উৎসবে সব সময়ই সাংস্কৃতিক চর্চাকে অব্যাহত ধারায় এগিয়ে নিয়ে যাচ্ছে। কেন্দ্রীয় শহীদ মিনার এলাকায় বছরের বিভিন্ন সময়ে নাট্যোৎসব ও সাংস্কৃতিক উৎসব অনুষ্ঠিত হয়ে থাকে। একুশে ফেব্রুয়ারিকে কেন্দ্র করে প্রতি বছরের ফেব্রুয়ারি মাসের পুরোটা জুড়ে বাংলা একাডেমিতে একুশে বইমেলার আয়োজন করা হয়। বাংলা নববর্ষকে বরণ করতে পহেলা বৈশাখে রমনা পার্কে ছায়ানটের অনুষ্ঠানসহ সারাদিন গোটা অঞ্চলে সাংস্কৃতিক উৎসব চলে। সাংস্কৃতিক হৃদ্যতার ধারাবাহিকতায় আগারগাঁওয়ের মুক্তিযুদ্ধ জাদুঘরও সারা বছর ধরে বিভিন্ন অনুষ্ঠানমালার আয়োজন করে।

শিক্ষা ও শিক্ষা প্রতিষ্ঠান 

১৯০৫ খ্রিষ্টাব্দে বঙ্গভঙ্গের সময় হতেই ঢাকা এই প্রাদেশিক রাজধানীর শিক্ষার কেন্দ্র হয়ে ওঠে। এই সময়ই ১৯২১ খ্রিষ্টাব্দে ঢাকা বিশ্ববিদ্যালয় স্থাপিত হয়। ১৯৮০'র দশক পর্যন্ত ঢাকা বিশ্ববিদ্যালয়কে কেন্দ্র করে এর আশেপাশের এলাকাকে এডুকেশন ডিস্ট্রিক্ট বলা হতো। এই এডুকেশন ডিস্ট্রিক্টের অন্যান্য শিক্ষা প্রতিষ্ঠানগুলো হচ্ছে আইডিয়াল স্কুল এন্ড কলেজ,মতিঝিল মডেল স্কুল এন্ড কলেজ, গবর্নমেন্ট ল্যাবরেটরি হাই স্কুল,সরকারি বিজ্ঞান কলেজ, ভিকারুননেসা নুন স্কুল এন্ড কলেজ, উইলস্ লিটল ফ্লাওয়ার স্কুল এন্ড কলেজ, ঢাকা কলেজ,ঢাকা সিটি কলেজ,হলিক্রস কলেজ, নটর ডেম কলেজ, তেজগাঁও কলেজ (পূর্বে নাইট কলেজ), ইউনিভার্সিটি ল্যাবরেটরী স্কুল, ইডেন মহিলা কলেজ, ইষ্ট এন্ড হাই স্কুল, অগ্রণী বালিকা বিদ্যালয়, আজিমপুর গার্লস স্কুল, বেগম বদরুন্নেসা কলেজ, ঢাকা মেডিকেল কলেজ, ঢাকা ডেন্টাল কলেজ, ঢাকা আর্ট কলেজ (চারুকলা ইন্সটিটিউট) প্রভৃতি।

ঐতিহ্যগতভাবে ঢাকা বিশ্ববিদ্যালয়ের সুনাম সৃষ্টি হয়েছিলো ব্রিটিশ শাসনামলে। তখন একে প্রাচ্যের অক্সফোর্ড বলা হতো। বুদ্ধদেব বসুর মতো ছাত্র এবং বিজ্ঞানী সত্যেন বোসের মতো শিক্ষক তখন ঢাকা বিশ্ববিদ্যালয়ের সুনামকে উচ্চ শিখরে নিয়ে গিয়েছিলেন। বিশ্ববিদ্যালয়ের কার্জন হলটি সভ্যতার স্বাক্ষর বহন করে। চারুকলা ইনস্টিটিউটের উদ্যোগে পহেলা বৈশাখে আয়োজিত হয় বর্ণিল শোভাযাত্রা। অন্যদিকে পুরান ঢাকায় ১৮৫৮ সাল থেকে জগন্নাথ বিশ্ববিদ্যালয় কেন্দ্রিক সাংস্কৃতিক কেন্দ্র হিসেবে চলে আসছে।

বাংলাদেশের শিক্ষাব্যবস্থায় প্রধানত তিনটি মূল ধারা রয়েছে; এগুলোর প্রথমটি হচ্ছে সরকার নির্ধারিত পাঠক্রম (যা বাংলা অথবা ইংরেজি মিডিয়ামে পড়াশোনা করা যায়), দ্বিতীয়টি হচ্ছে বেসরকারি কেজি লেভেল হতে এ লেভেল পর্যন্ত ইংরেজি মিডিয়ামের ব্রিটিশ পাঠক্রম এবং তুতীয়টি হচ্ছে মূলত আরবি, ফার্সি ও উর্দু ভাষানির্ভর মাদ্রাসা শিক্ষাব্যবস্থা। মাদ্রাসাভিত্তিক এই শিক্ষা প্রতিষ্ঠানগুলোর কোনো কোনোটি সরকার নির্ধারিত পাঠক্রম এবং কোনো কোনোটি নিজস্ব পাঠক্রম ব্যবহার করে শিক্ষা প্রদান করে। শেষোক্ত এশ্রেণীর শিক্ষা প্রতিষ্ঠানগুলোর উপর সরকারের কোনো প্রশাসনিক নিয়ন্ত্রণ নেই। এই একই চিত্র ঢাকার শিক্ষা প্রতিষ্ঠানগুলোর ক্ষেত্রে প্রায় একশভাগ প্রযোজ্য।

বলা বাহুল্য নয় যে, এই শিক্ষা প্রতিষ্ঠানগুলোর অধিকাংশই ঢাকায় অবস্থিত। আশির দশক পর্যন্ত ঢাকাসহ বাংলাদেশে পাবলিক শিক্ষা প্রতিষ্ঠানই শিক্ষাক্ষেত্রে মূল চালিকাশক্তি ছিলো। এর পর হতেই বেসরকারি খাতে কিন্ডারগার্টেন ও স্কুলের প্রসার হতে শুরু করে। ১৯৯২ খ্রিষ্টাব্দে বেসরকারি বিশ্ববিদ্যালয় আইন ও ১৯৯৮ খ্রিষ্টাব্দে তার সংশোধন বেসরকারি বিশ্ববিদ্যালয় স্থাপনে এক বাঁধভাঙ্গা জোয়ার নিয়ে আসে। এযাবত প্রায় ৫৪টি বেসরকারি বিশ্ববিদ্যালয় স্থাপনের অনুমতি দিয়েছে সরকার। লক্ষণীয় বিষয় হলো এর মধ্যে প্রায় ৪৫টিই হলো ঢাকা বিভাগে।

ঢাকার সরকারি বিশ্ববিদ্যালয়সমূহ 

বাংলাদেশে বর্তমানে সর্বমোট ৫৩টির অধিক পাবলিক বা সরকারি বিশ্ববিদ্যালয়ের ১০টি হচ্ছে ঢাকা শহরে (তন্মধ্যে ২টি ক্যাম্পাস অস্থায়ী)। এগুলো হলো : 
 ঢাকা বিশ্ববিদ্যালয় (স্থাপিত : ১৯২১)
 বাংলাদেশ প্রকৌশল বিশ্ববিদ্যালয় (স্থাপিত : ১৯৬২)
 বঙ্গবন্ধু শেখ মুজিব মেডিকেল বিশ্ববিদ্যালয় (স্থাপিত : ১৯৯৮)
 শেরেবাংলা কৃষি বিশ্ববিদ্যালয় (স্থাপিত : ২০০১)
 জগন্নাথ বিশ্ববিদ্যালয় (স্থাপিত : ২০০৫)
 বাংলাদেশ ইউনিভার্সিটি অব প্রফেশনালস (স্থাপিত : ২০০৮)
 বাংলাদেশ টেক্সটাইল বিশ্ববিদ্যালয় (স্থাপিত : ২০১০)
 বঙ্গবন্ধু শেখ মুজিবুর রহমান মেরিটাইম বিশ্ববিদ্যালয় (অস্থায়ী ক্যাম্পাস) (স্থাপিত : ২০১৩)
 ইসলামি আরবি বিশ্ববিদ্যালয় (স্থাপিত : ২০১৪)
 বঙ্গবন্ধু শেখ মুজিবুর রহমান অ্যাভিয়েশন অ্যান্ড অ্যারোস্পেস বিশ্ববিদ্যালয় (স্থাপিত :২০১৯)

ব

# Unicode Support

```{currentmodule} click
```

Click has to take extra care to support Unicode text in different environments.

- The command line in Unix is traditionally bytes, not Unicode. While there are encoding hints, there are some
  situations where this can break. The most common one is SSH connections to machines with different locales.

  Misconfigured environments can cause a wide range of Unicode problems due to the lack of support for roundtripping
  surrogate escapes. This will not be fixed in Click itself!

- Standard input and output is opened in text mode by default. Click has to reopen the stream in binary mode in certain
  situations. Because there is no standard way to do this, it might not always work. Primarily this can become a problem
  when testing command-line applications.

  This is not supported:

  ```python
  sys.stdin = io.StringIO('Input here')
  sys.stdout = io.StringIO()
  ```

  Instead you need to do this:

  ```python
  input = 'Input here'
  in_stream = io.BytesIO(input.encode('utf-8'))
  sys.stdin = io.TextIOWrapper(in_stream, encoding='utf-8')
  out_stream = io.BytesIO()
  sys.stdout = io.TextIOWrapper(out_stream, encoding='utf-8')
  ```

  Remember in that case, you need to use `out_stream.getvalue()` and not `sys.stdout.getvalue()` if you want to access
  the buffer contents as the wrapper will not forward that method.

- `sys.stdin`, `sys.stdout` and `sys.stderr` are by default text-based. When Click needs a binary stream, it attempts to
  discover the underlying binary stream.

- `sys.argv` is always text. This means that the native type for input values to the types in Click is Unicode, not
  bytes.

  This causes problems if the terminal is incorrectly set and Python does not figure out the encoding. In that case, the
  Unicode string will contain error bytes encoded as surrogate escapes.

- When dealing with files, Click will always use the Unicode file system API by using the operating system's reported or
  guessed filesystem encoding. Surrogates are supported for filenames, so it should be possible to open files through
  the {func}`File` type even if the environment is misconfigured.

## Surrogate Handling

Click does all the Unicode handling in the standard library and is subject to its behavior. Unicode requires extra care.
The reason for this is that the encoding detection is done in the interpreter, and on Linux and certain other operating
systems, its encoding handling is problematic.

The biggest source of frustration is that Click scripts invoked by init systems, deployment tools, or cron jobs will
refuse to work unless a Unicode locale is exported.

If Click encounters such an environment it will prevent further execution to force you to set a locale. This is done
because Click cannot know about the state of the system once it's invoked and restore the values before Python's Unicode
handling kicked in.

If you see something like this error:

```console
Traceback (most recent call last):
  ...
RuntimeError: Click will abort further execution because Python was
  configured to use ASCII as encoding for the environment. Consult
  https://click.palletsprojects.com/unicode-support/ for mitigation
  steps.
```

You are dealing with an environment where Python thinks you are restricted to ASCII data. The solution to these problems
is different depending on which locale your computer is running in.

For instance, if you have a German Linux machine, you can fix the problem by exporting the locale to `de_DE.utf-8`:

```console
export LC_ALL=de_DE.utf-8
export LANG=de_DE.utf-8
```

If you are on a US machine, `en_US.utf-8` is the encoding of choice. On some newer Linux systems, you could also try
`C.UTF-8` as the locale:

```console
export LC_ALL=C.UTF-8
export LANG=C.UTF-8
```

On some systems it was reported that `UTF-8` has to be written as `UTF8` and vice versa. To see which locales are
supported you can invoke `locale -a`.

You need to export the values before you invoke your Python script.

In Python 3.7 and later you will no longer get a `RuntimeError` in many cases thanks to {pep}`538` and {pep}`540`, which
changed the default assumption in unconfigured environments. This doesn't change the general issue that your locale may
be misconfigured.

# Contributing

This is a quick reference for Click-specific development
tasks. For setting up the development environment and the
general contribution workflow, see the Pallets [quick
reference](https://palletsprojects.com/contributing/quick/)
and the [detailed contributing
guide](https://palletsprojects.com/contributing/).

## Extra Test Environments

Click includes some extra test environments:

-   `tox r -e stress` runs stress tests for race conditions
    in Click's test runner.

    ```shell-session
    $ tox r -e stress
    ```

-   `tox r -e random` runs tests in parallel in a random
    order to detect test pollution.

    ```shell-session
    $ tox r -e random
    ```

-   A CI workflow (`.github/workflows/test-flask.yaml`)
    runs Flask's test suite to catch downstream
    regressions.

## Code Style

Avoid ternary expressions (`x if cond else y`): coverage
cannot measure both branches. Use an explicit `if`/`else`
block instead.

Do not add unnecessary dependencies. If a feature can be
implemented with the standard library, do not pull in an
external package for it.

## Formatting

Wrap lines in Markdown files at 80 characters.

<a id="top"></a>
# Event Listeners

An event listener is a bit like a reporter, in that it responds to various
reporter events in Catch2, but it is not expected to write any output.
Instead, an event listener performs actions within the test process, such
as performing global initialization (e.g. of a C library), or cleaning out
in-memory logs if they are not needed (the test case passed).

Unlike reporters, each registered event listener is always active. Event
listeners are always notified before reporter(s).

To write your own event listener, you should derive from `Catch::EventListenerBase`,
as it provides empty stubs for all reporter events, allowing you to
only override events you care for. Afterwards you have to register it
with Catch2 using `CATCH_REGISTER_LISTENER` macro, so that Catch2 knows
about it and instantiates it before running tests.

Example event listener:
```cpp
#include <catch2/reporters/catch_reporter_event_listener.hpp>
#include <catch2/reporters/catch_reporter_registrars.hpp>

class testRunListener : public Catch::EventListenerBase {
public:
    using Catch::EventListenerBase::EventListenerBase;

    void testRunStarting(Catch::TestRunInfo const&) override {
        lib_foo_init();
    }
};

CATCH_REGISTER_LISTENER(testRunListener)
```

_Note that you should not use any assertion macros within a Listener!_

[You can find the list of events that the listeners can react to on its
own page](reporter-events.md#top).


---

[Home](Readme.md#top)

<a id="top"></a>
# Compile-time configuration

**Contents**<br>
[Prefixing Catch macros](#prefixing-catch-macros)<br>
[Terminal colour](#terminal-colour)<br>
[Console width](#console-width)<br>
[stdout](#stdout)<br>
[Fallback stringifier](#fallback-stringifier)<br>
[Default reporter](#default-reporter)<br>
[Bazel support](#bazel-support)<br>
[C++11 toggles](#c11-toggles)<br>
[C++17 toggles](#c17-toggles)<br>
[Other toggles](#other-toggles)<br>
[Enabling stringification](#enabling-stringification)<br>
[Disabling exceptions](#disabling-exceptions)<br>
[Disabling deprecation warnings](#disabling-deprecation-warnings)<br>
[Overriding Catch's debug break (`-b`)](#overriding-catchs-debug-break--b)<br>
[Static analysis support](#static-analysis-support)<br>
[Thread safety in assertions (and messages)](#thread-safety-in-assertions-and-messages)<br>

Catch2 is designed to "just work" as much as possible, and most of the
configuration options below are changed automatically during compilation,
according to the detected environment. However, this detection can also
be overridden by users, using macros documented below, and/or CMake options
with the same name.


## Prefixing Catch macros

    CATCH_CONFIG_PREFIX_ALL       // Prefix all macros with CATCH_
    CATCH_CONFIG_PREFIX_MESSAGES  // Prefix only message macros ((UNSCOPED_)INFO, WARN, (UNSCOPED_)CAPTURE)

To keep test code clean and uncluttered Catch uses short macro names (e.g. ```TEST_CASE``` and ```REQUIRE```). Occasionally these may conflict with identifiers from platform headers or the system under test. In this case the above identifier can be defined. This will cause all the Catch user macros to be prefixed with ```CATCH_``` (e.g. ```CATCH_TEST_CASE``` and ```CATCH_REQUIRE```).


## Terminal colour

    CATCH_CONFIG_COLOUR_WIN32     // Force enables compiling colouring impl based on Win32 console API
    CATCH_CONFIG_NO_COLOUR_WIN32  // Force disables ...

Yes, Catch2 uses the british spelling of colour.

Catch2 attempts to autodetect whether the Win32 console colouring API,
`SetConsoleTextAttribute`, is available, and if it is available it compiles
in a console colouring implementation that uses it.

This option can be used to override Catch2's autodetection and force the
compilation either ON or OFF.


## Console width

    CATCH_CONFIG_CONSOLE_WIDTH = x // where x is a number

Catch formats output intended for the console to fit within a fixed number of characters. This is especially important as indentation is used extensively and uncontrolled line wraps break this.
By default a console width of 80 is assumed but this can be controlled by defining the above identifier to be a different value.

## stdout

    CATCH_CONFIG_NOSTDOUT

To support platforms that do not provide `std::cout`, `std::cerr` and
`std::clog`, Catch does not use them directly, but rather calls
`Catch::cout`, `Catch::cerr` and `Catch::clog`. You can replace their
implementation by defining `CATCH_CONFIG_NOSTDOUT` and implementing
them yourself, their signatures are:

    std::ostream& cout();
    std::ostream& cerr();
    std::ostream& clog();

[You can see an example of replacing these functions here.](
../examples/231-Cfg-OutputStreams.cpp)


## Fallback stringifier

By default, when Catch's stringification machinery has to stringify
a type that does not specialize `StringMaker`, does not overload `operator<<`,
is not an enumeration and is not a range, it uses `"{?}"`. This can be
overridden by defining `CATCH_CONFIG_FALLBACK_STRINGIFIER` to name of a
function that should perform the stringification instead.

All types that do not provide `StringMaker` specialization or `operator<<`
overload will be sent to this function (this includes enums and ranges).
The provided function must return `std::string` and must accept any type,
e.g. via overloading.

_Note that if the provided function does not handle a type and this type
requires to be stringified, the compilation will fail._


## Default reporter

Catch's default reporter can be changed by defining macro
`CATCH_CONFIG_DEFAULT_REPORTER` to string literal naming the desired
default reporter.

This means that defining `CATCH_CONFIG_DEFAULT_REPORTER` to `"console"`
is equivalent with the out-of-the-box experience.


## Bazel support

Compiling Catch2 with `CATCH_CONFIG_BAZEL_SUPPORT` force-enables Catch2's
support for Bazel's environment variables (normally Catch2 looks for
`BAZEL_TEST=1` env var first).

This can be useful if you are using older versions of Bazel, that do not
yet have `BAZEL_TEST` env var support.

> `CATCH_CONFIG_BAZEL_SUPPORT` was [introduced](https://github.com/catchorg/Catch2/pull/2399) in Catch2 3.0.1.

> `CATCH_CONFIG_BAZEL_SUPPORT` was [deprecated](https://github.com/catchorg/Catch2/pull/2459) in Catch2 3.1.0.


## C++11 toggles

    CATCH_CONFIG_CPP11_TO_STRING // Use `std::to_string`

Because we support platforms whose standard library does not contain
`std::to_string`, it is possible to force Catch to use a workaround
based on `std::stringstream`. On platforms other than Android,
the default is to use `std::to_string`. On Android, the default is to
use the `stringstream` workaround. As always, it is possible to override
Catch's selection, by defining either `CATCH_CONFIG_CPP11_TO_STRING` or
`CATCH_CONFIG_NO_CPP11_TO_STRING`.


## C++17 toggles

    CATCH_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS  // Override std::uncaught_exceptions (instead of std::uncaught_exception) support detection
    CATCH_CONFIG_CPP17_STRING_VIEW          // Override std::string_view support detection (Catch provides a StringMaker specialization by default)
    CATCH_CONFIG_CPP17_VARIANT              // Override std::variant support detection (checked by CATCH_CONFIG_ENABLE_VARIANT_STRINGMAKER)
    CATCH_CONFIG_CPP17_OPTIONAL             // Override std::optional support detection (checked by CATCH_CONFIG_ENABLE_OPTIONAL_STRINGMAKER)
    CATCH_CONFIG_CPP17_BYTE                 // Override std::byte support detection (Catch provides a StringMaker specialization by default)

> `CATCH_CONFIG_CPP17_STRING_VIEW` was [introduced](https://github.com/catchorg/Catch2/issues/1376) in Catch2 2.4.1.

Catch contains basic compiler/standard detection and attempts to use
some C++17 features whenever appropriate. This automatic detection
can be manually overridden in both directions, that is, a feature
can be enabled by defining the macro in the table above, and disabled
by using `_NO_` in the macro, e.g. `CATCH_CONFIG_NO_CPP17_UNCAUGHT_EXCEPTIONS`.


## Other toggles

    CATCH_CONFIG_COUNTER                    // Use __COUNTER__ to generate unique names for test cases
    CATCH_CONFIG_WINDOWS_SEH                // Enable SEH handling on Windows
    CATCH_CONFIG_FAST_COMPILE               // Sacrifices some (rather minor) features for compilation speed
    CATCH_CONFIG_POSIX_SIGNALS              // Enable handling POSIX signals
    CATCH_CONFIG_WINDOWS_CRTDBG             // Enable leak checking using Windows's CRT Debug Heap
    CATCH_CONFIG_DISABLE_STRINGIFICATION    // Disable stringifying the original expression
    CATCH_CONFIG_DISABLE                    // Disables assertions and test case registration
    CATCH_CONFIG_WCHAR                      // Enables use of wchart_t
    CATCH_CONFIG_EXPERIMENTAL_REDIRECT      // Enables the new (experimental) way of capturing stdout/stderr
    CATCH_CONFIG_USE_ASYNC                  // Force parallel statistical processing of samples during benchmarking
    CATCH_CONFIG_ANDROID_LOGWRITE           // Use android's logging system for debug output
    CATCH_CONFIG_GLOBAL_NEXTAFTER           // Use nextafter{,f,l} instead of std::nextafter
    CATCH_CONFIG_GETENV                     // System has a working `getenv`
    CATCH_CONFIG_USE_BUILTIN_CONSTANT_P     // Use __builtin_constant_p to trigger warnings

> [`CATCH_CONFIG_ANDROID_LOGWRITE`](https://github.com/catchorg/Catch2/issues/1743) and [`CATCH_CONFIG_GLOBAL_NEXTAFTER`](https://github.com/catchorg/Catch2/pull/1739) were introduced in Catch2 2.10.0

> `CATCH_CONFIG_GETENV` was [introduced](https://github.com/catchorg/Catch2/pull/2562) in Catch2 3.2.0

> `CATCH_CONFIG_USE_BUILTIN_CONSTANT_P` was introduced in Catch2 3.8.0

Currently Catch enables `CATCH_CONFIG_WINDOWS_SEH` only when compiled with MSVC, because some versions of MinGW do not have the necessary Win32 API support.

`CATCH_CONFIG_POSIX_SIGNALS` is on by default, except when Catch is compiled under `Cygwin`, where it is disabled by default (but can be force-enabled by defining `CATCH_CONFIG_POSIX_SIGNALS`).

`CATCH_CONFIG_GETENV` is on by default, except when Catch2 is compiled for
platforms that lacks working `std::getenv` (currently Windows UWP and
Playstation).

`CATCH_CONFIG_WINDOWS_CRTDBG` is off by default. If enabled, Windows's
CRT is used to check for memory leaks, and displays them after the tests
finish running. This option only works when linking against the default
main, and must be defined for the whole library build.

`CATCH_CONFIG_WCHAR` is on by default, but can be disabled. Currently
it is only used in support for DJGPP cross-compiler.

With the exception of `CATCH_CONFIG_EXPERIMENTAL_REDIRECT`,
these toggles can be disabled by using `_NO_` form of the toggle,
e.g. `CATCH_CONFIG_NO_WINDOWS_SEH`.

`CATCH_CONFIG_USE_BUILTIN_CONSTANT_P` is ON by default for Clang and GCC
(but as far as possible, not for other compilers masquerading for these
two). However, it can cause bugs where the enclosed code is evaluated, even
though it should not be, e.g. in [#2925](https://github.com/catchorg/Catch2/issues/2925).


### `CATCH_CONFIG_FAST_COMPILE`
This compile-time flag speeds up compilation of assertion macros by ~20%,
by disabling the generation of assertion-local try-catch blocks for
non-exception family of assertion macros ({`REQUIRE`,`CHECK`}{``,`_FALSE`, `_THAT`}).
This disables translation of exceptions thrown under these assertions, but
should not lead to false negatives.

`CATCH_CONFIG_FAST_COMPILE` has to be either defined, or not defined,
in all translation units that are linked into single test binary.

### `CATCH_CONFIG_DISABLE_STRINGIFICATION`
This toggle enables a workaround for VS 2017 bug. For details see [known limitations](limitations.md#visual-studio-2017----raw-string-literal-in-assert-fails-to-compile).

### `CATCH_CONFIG_DISABLE`
This toggle removes most of Catch from given file. This means that `TEST_CASE`s are not registered and assertions are turned into no-ops. Useful for keeping tests within implementation files (ie for functions with internal linkage), instead of in external files.

This feature is considered experimental and might change at any point.

_Inspired by Doctest's `DOCTEST_CONFIG_DISABLE`_


## Enabling stringification

By default, Catch does not stringify some types from the standard library. This is done to avoid dragging in various standard library headers by default. However, Catch does contain these and can be configured to provide them, using these macros:

    CATCH_CONFIG_ENABLE_PAIR_STRINGMAKER     // Provide StringMaker specialization for std::pair
    CATCH_CONFIG_ENABLE_TUPLE_STRINGMAKER    // Provide StringMaker specialization for std::tuple
    CATCH_CONFIG_ENABLE_VARIANT_STRINGMAKER  // Provide StringMaker specialization for std::variant, std::monostate (on C++17)
    CATCH_CONFIG_ENABLE_OPTIONAL_STRINGMAKER // Provide StringMaker specialization for std::optional (on C++17)
    CATCH_CONFIG_ENABLE_ALL_STRINGMAKERS     // Defines all of the above

> `CATCH_CONFIG_ENABLE_VARIANT_STRINGMAKER` was [introduced](https://github.com/catchorg/Catch2/issues/1380) in Catch2 2.4.1.

> `CATCH_CONFIG_ENABLE_OPTIONAL_STRINGMAKER` was [introduced](https://github.com/catchorg/Catch2/issues/1510) in Catch2 2.6.0.

## Disabling exceptions

> Introduced in Catch2 2.4.0.

By default, Catch2 uses exceptions to signal errors and to abort tests
when an assertion from the `REQUIRE` family of assertions fails. We also
provide an experimental support for disabling exceptions. Catch2 should
automatically detect when it is compiled with exceptions disabled, but
it can be forced to compile without exceptions by defining

    CATCH_CONFIG_DISABLE_EXCEPTIONS

Note that when using Catch2 without exceptions, there are 2 major
limitations:

1) If there is an error that would normally be signalled by an exception,
the exception's message will instead be written to `Catch::cerr` and
`std::terminate` will be called.
2) If an assertion from the `REQUIRE` family of macros fails,
`std::terminate` will be called after the active reporter returns.


There is also a customization point for the exact behaviour of what
happens instead of exception being thrown. To use it, define

    CATCH_CONFIG_DISABLE_EXCEPTIONS_CUSTOM_HANDLER

and provide a definition for this function:

```cpp
namespace Catch {
    [[noreturn]]
    void throw_exception(std::exception const&);
}
```


## Disabling deprecation warnings

> Introduced in Catch2 3.9.0

Catch2 has started using the C++ macro `[[deprecated]]` to mark things
that are deprecated and should not be used any more. If you need to
temporarily disable these warnings, use

    CATCH_CONFIG_NO_DEPRECATION_ANNOTATIONS

Catch2 currently does not support more fine-grained deprecation warning
control, nor do we plan to.


## Overriding Catch's debug break (`-b`)

> [Introduced](https://github.com/catchorg/Catch2/pull/1846) in Catch2 2.11.2.

You can override Catch2's break-into-debugger code by defining the
`CATCH_BREAK_INTO_DEBUGGER()` macro. This can be used if e.g. Catch2 does
not know your platform, or your platform is misdetected.

The macro will be used as is, that is, `CATCH_BREAK_INTO_DEBUGGER();`
must compile and must break into debugger.


## Static analysis support

> Introduced in Catch2 3.4.0.

Some parts of Catch2, e.g. `SECTION`s, can be hard for static analysis
tools to reason about. Catch2 can change its internals to help static
analysis tools reason about the tests.

Catch2 automatically detects some static analysis tools (initial
implementation checks for clang-tidy and Coverity), but you can override
its detection (in either direction) via

```
CATCH_CONFIG_EXPERIMENTAL_STATIC_ANALYSIS_SUPPORT     // force enables static analysis help
CATCH_CONFIG_NO_EXPERIMENTAL_STATIC_ANALYSIS_SUPPORT  // force disables static analysis help
```

_As the name suggests, this is currently experimental, and thus we provide
no backwards compatibility guarantees._

**DO NOT ENABLE THIS FOR BUILDS YOU INTEND TO RUN.** The changed internals
are not meant to be runnable, only "scannable".



<a id="experimental-thread-safety"></a>
## Thread safety in assertions (and messages)

> Introduced in Catch2 3.9.0

> Made non-experimental in Catch2 3.12.0

Catch2 can optionally support thread-safe assertions, that means, multiple
user-spawned threads can use the assertion macros at the same time. Due
to the performance cost this imposes even on single-threaded usage, Catch2
defaults to non-thread-safe assertions.

    CATCH_CONFIG_THREAD_SAFE_ASSERTIONS     // enables thread safe assertions
    CATCH_CONFIG_NO_THREAD_SAFE_ASSERTIONS  // force-disables thread safe assertions

See [the documentation on thread safety in Catch2](thread-safety.md#top)
for details on which macros are safe and other notes.


---

[Home](Readme.md#top)

欧罗巴洲（），简称欧洲，是位于欧亚大陆西北部的一个洲，面积約，總人口達 748,571,960（截止2022年7月底），世界人口第三多的洲，僅次於亚洲和非洲，人口密度平均每平方公里70人，共有50個已獨立的主權國家。

欧洲东以烏拉山脈、烏拉河，东南以裏海、高加索山脉和黑海與亞洲為界，西、西北隔大西洋、格陵兰海、丹麦海峡与北美洲相望，北接北極海，南隔地中海与非洲相望。

歐陸最北端是挪威的北角，最南端是西班牙的马罗基角，欧洲是世界上第二小的洲、大陆，僅比大洋洲大一些，其與亞洲合稱為欧亚大陆，而與亞洲、非洲合稱為歐亞非大陸。

歐洲嚴格來說在地質學上也不算是一個洲，只能算是為了地緣政治和文化而劃分的洲。歐洲並不是由海洋或其他自然邊界完全或幾乎完全與其他陸地隔離的相連的陸地。通常，根据政治、经济、文化或实际考虑，欧洲的边界线并不总是一样的。这就使得人们产生了几个不同“欧洲”的观念。

名称 

在古希腊神话中，欧罗巴（）是一位腓尼基公主，她受到变成公牛的宙斯的引诱。一种说法认为她的名称来自古希腊语语素“”（；）与“”（；属格：，；），因此其复合形式“”（）可能有“宽广的视野”或“辽阔的方位”之意。

世界上大多数语言使用“” 或“Europa”的音译词指代该大陆。在中文中，“欧洲”是“欧罗巴洲”一词的缩写，后者是由利玛窦于自己翻译的《坤舆万国全图》中率先使用的。尽管在日语中片假名“”（）正逐渐常用，在欧洲联盟的“”（）等词汇中也保留了来自漢字的“”（）用法。在一些突厥语系语言中，除了“”或“”，原先的波斯语名称“”（法蘭吉斯坦；）也会用来指代欧洲的大部分地区。

定义 

可点击欧洲地图：显示与亚洲大陆因历史原因形成的边界线。（参见亚洲与欧洲的分界线获得更多信息）。

图例：蓝 = 洲际国家；绿 = 有时会被认为是欧洲，但在欧洲边界线之外。

地理

地形 

歐洲的地形樣貌頗為豐富。

東歐是一望無際的大草原地形，歐洲東南界為高加索山脈，其主峰厄爾布魯士峰海拔5642米，是歐洲最高峰。其餘歐洲地區除法國、荷蘭、比利時等沿海地區有大片的平原外，其餘多為山地丘陵、平原和高地交錯分佈的地形，阿爾卑斯山山脈橫亙歐洲中部，法國與西班牙、安道爾以庇里牛斯山山脈為界，北歐則多冰河地形，有許多冰河切割消溶入海後所造成的峽灣地形，冰島則除了冰河地形以外有很多火山地形。

水文 

歐洲流經數國的大河有萊茵河、多瑙河、易北河、奥得河等。此外主要河流還有法國境內的塞納河、卢瓦尔河、加隆河等、俄國境內的伏尔加河、第聶伯河、烏拉爾河、英国境内的泰晤士河、意大利境内的波河等。

除了河流，歐洲有許多湖泊。其中冰河所遺留下的冰蚀湖使芬蘭被稱為千湖之國。

氣候 
歐洲緯度是在北緯35度以北，大部分屬溫帶氣候，並向北延伸至北極圈，故北歐西部及南部屬温帶氣候。整个欧洲不存在最热月平均气温高于30摄氏度的酷暑区，亦不存在最冷月平均气温低于零下20摄氏度的酷寒区，灾害性天气亦较其他各洲少。

在西風的吹拂及洋流的調節之下，西歐及北欧西部沿海的氣候是全球正偏差最大的區域，因沿海有北大西洋暖流流經，故此冬无严寒，夏无酷暑，宜人居住，多屬於溫帶海洋性氣候。

東歐則屬温带大陸性湿润氣候，年溫差较西欧大，但仍较同纬度的东亚大陆小。南歐緊鄰地中海，夏乾冬雨，因為夏天副熱帶高壓壟罩，冬天西風吹拂。而北冰洋沿岸地区属苔原气候。

历史

远古历史 

根据这两、三百年的考古发掘，证实欧洲（包括英国等地）在舊石器时代已经有人類活动。

公元前4000年－前26世紀，西欧的凯尔特人就出现巨石文化，现在还留有欧洲巨石建筑遗迹。地中海东部的爱琴海被认为是欧洲文明的发祥地。

公元前2000年左右，古希腊人的祖先就定居在爱琴海的克里特岛，它也成为古希腊文明的发源地，并且逐渐發展出城邦文化。

公元前5世纪，伯罗奔尼撒战争过后，古希腊本土逐渐走向衰落，但是其文化影响力继续扩大，

公元前3世纪，希腊边境馬其頓王国的亞歷山大大帝征服埃及和波斯，建立橫跨歐亞非三洲的大帝國，将希腊文化传播到亞洲和非洲地区，史称希腊化时代，给人类留下丰富的文化遗产。

公元前27年，古罗马兴起，成立羅馬帝国，成为一个统治欧洲、西亚和北非的大帝国，地中海成为其内海。亚平宁半岛是當時歐洲政治和经济的中心地区。

公元1世纪后，基督教逐渐在罗马境内传播开来。

313年，基督教被定为罗马国教，取得在欧洲的统治地位。
3世纪後期，罗马帝国逐渐衰弱。
376年，匈人擊敗東哥德王國，哥德人被迫渡過多瑙河進入西羅馬帝國。
395年，分裂成为東、西两個帝国。北欧的日尔曼人及东欧的斯拉夫人相继兴起。

4世紀，來自東方的匈人迫使東歐各族不斷向西遷移。
436年，西哥德人滅亡西羅馬帝國，西歐進入中世纪。
帝國的東半部（東羅馬帝國）則持續發展至1453年，最後被鄂圖曼土耳其人所滅。

中古史 

中世纪时期，许多民族相繼建立王國，採行封建采邑制，战争不断，基督教教會遂逐漸成為社會上安定人心、救濟民眾的重要機構。修士的虔誠服務、默默行善及清高廉潔的形象，對傳布基督信仰助益甚多。

8世紀，查理曼建立查理曼帝國。
843年，即分裂。该帝国的東半部发展成为神圣罗马帝国。英国、法国、德国、意大利等许多国家的雛型都是在这一时期形成建立起来的。

天主教教會在西歐握有極大力量，所有知識傳承都在修道院中進行。宗教迫害和十字军东征给欧洲人民带来很大的灾难，这一时期被啟蒙時代的學者稱為黑暗時代。在这段时间内，欧洲，尤其是南欧和东欧遭受亚洲游牧民族的多次入侵，比如阿拉伯人、马扎尔人、阿瓦尔人、蒙古人和土耳其人。

近代史 
14世纪开始，在西欧和南欧的一些国家中，特别是英國、法國、葡萄牙、西班牙，资本主义开始萌芽，通过地理大发现和对海外的冒險，足跡遍及非洲、美洲和亚洲。

同一時期歐洲開始發生文化的大量精進，被稱為文藝復興，這也引發了宗教革命，許多國家脫離天主教教會的管轄而改奉新教，政教合一的各國常因教派不同而引發政爭，甚至有許多的宗教戰爭。在西歐的政教紛擾之際，東方信奉東正教的俄羅斯則在彼得大帝及隨後的幾位沙皇領導下逐漸強盛。

16世纪，原来统治德意志、西班牙、葡萄牙及其殖民地的哈布斯堡王朝衰落，最终在三十年战争中丧失了欧洲霸主的地位。

1667年到1763年，是新興的英国、法国、荷蘭三強鼎立，一共爆发六次战争：法国与西班牙——荷兰的遗产战争（1667年～1668年）、法国与荷兰的法荷战争（1672年～1678年）、反法同盟与法国的大同盟战争（1688年～1697年）、西班牙王位继承战争（1700年～1713年）、英国——奥地利与法国——普鲁士的奥地利王位继承战争（1740年～1748年）和英国——普鲁士与法国——奥地利——俄国的七年战争（1756年～1763年）。

这些战争的最后结果：英国击败法国和荷兰，夺取大片海外殖民地，建立了“日不落帝国”；法国的君主专制制度崩溃，最终爆发震撼世界的法国大革命。

17世纪末，英國政治上發生光榮革命。18世纪，英國開始工业革命，隨即影響歐洲大陸，也促進了民族國家的興起。

義大利、德國在19世紀完成統一，隨著科技的進步、對外界的不斷探索及進化論的提出，歐洲成為帝國主義的搖籃，掠奪全世界的資源。

20世纪初，帝國主義的極度擴張終於導致欧洲变为战争策源地，发生兩次世界大戰，使欧洲遭受很大的创伤并喪失世界霸權。歐洲國家陸續喪失其殖民地統治權。

第一次世界大戰期间，出现世界上第一个社会主义国家——苏联。二战后，在苏联的影响下，又出现一批社会主义国家。

1950年代开始，出现以美國为首的北大西洋公约组织成员国及以蘇聯为首的华沙条约组织缔约国兩個集團對峙的局面。

欧洲被划分为两个主要的政治经济阵营：东欧的共产主义和西欧的资本主义。

到1990年，随着苏联解体，冷战结束，欧洲的政治格局发生重大变化。东欧的社會主義國家重新回歸資本主義。

现在，“欧洲”这个词被更广泛的用来作为欧洲聯盟的代名词。现在欧盟有29个成员国，更多的一些成员身份谈判正在或即将进行。所有欧盟成员国都是歐洲委員會的成员国。

地區 

 欧洲可分为西欧、中欧、东欧、北欧和南欧、亞欧交界國地区：

（須注意的是，此分區方法並非唯一，根據地理、政治、文化等考量，可能會有不同的分區方式）

其他地区和有限承认的国家

聯合國的分區方法

政治 

歐洲是近代西方政治思想的主要發源地。在政治制度方面，無論是民主制、共和制、君主立憲制（內閣制）、雙首長制等均源自於歐洲，世界各國普受影響。

在政治色彩上，歐洲政治思潮從左到右，一列俱全，諸如無政府主義、納粹主義、法西斯主義、保守主義、君主主義、乃至社會主義、共產主義，均在歐洲政治史上扮演一定角色，此較諸其他各大洲，是為歐洲獨特之處。現在歐洲某些國家左派與右派輪流執政，形成鐘擺效應也為頗值關注。

欧洲一体化越来越成为欧洲发展的趋势。欧洲许多国家的政党之间组成各自的联盟，例如歐洲人民黨、欧洲绿党、欧洲自由民主改革党、歐洲左派黨、歐洲民主黨、歐洲自由聯盟等。除美國以外，北大西洋公約組織的會員國主要是由歐洲各國所組成。目前歐洲在聯合國共有44個會員國，其中英、法、俄是聯合國安理會的常任理事國。

现在的欧洲是世界最为关注的战略重点，欧盟的发展加强欧洲一体化，現時欧盟更為一個超國家組織，是影响世界经济政治发展的重要因素。在冷战结束后，美欧争夺欧洲主导权的斗争开始浮现出来。

欧洲对于同性恋人士的政策在世界上也是最为宽容的。在全球二十多个承认同性婚姻的国家中，欧洲就有十六个，分別是荷兰、比利时、西班牙、挪威、瑞典、葡萄牙、冰岛、丹麦、法国、卢森堡、爱尔兰、芬兰、英国、马耳他、德國及奥地利。另外欧洲还有十多个国家承认同性伴侣民事结合，他们是安道尔、捷克、斯洛文尼亚、瑞士、匈牙利、列支敦士登、克罗地亚、塞浦路斯、爱沙尼亚、希腊、意大利、圣马力诺。欧洲有37个国家立法禁止在就业、医疗等社会日常生活中基于对性倾向的歧视行为。此外，欧洲所有的国家规定两个成年人之间自愿的同性恋行为合法。

经济 

资本主义最早从欧洲发展起来，其工业和农业的机械化水平也是各洲中最高的。欧洲绝大多数国家都属发达国家，其中以北欧、西欧和中欧一些国家经济发展水平最高。

随着欧盟的发展，欧洲经济一体化程度越来越高，1979年3月13日开始在欧洲共同体内部使用欧洲货币单位作为计价结算的一种货币单位。现在歐元（€ ISO 4217碼EUR）是目前歐盟28個會員國中的18國（也有這18國以外的國家，已經是31個國家和地區的官方貨幣）所使用的貨幣。歐盟各國對於是否加入歐元區皆有自身利益的考量，目前有一半以上的歐盟會員國仍發行自己國家的货幣，並未加入歐元區的行列，例如：丹麦克朗等。歐元區是目前世界主要經濟體之一，歐元區經濟的榮枯深深地影響著全世界的景氣。

在欧洲一些传统产业中，农业的现代化水平很高。全洲耕地总面积约2.9亿公顷，农业人口比重为15％。但是由于人口稠密，消费高，大多数国家粮食不能自给。欧洲的工业产值是各洲中最高的，交通运输业極其发达，全洲有35万千米铁路；公路总长420万千米；海运总吨位约占世界的45％，具有很强的外贸经济的特点。此外，欧洲航空业和旅游业也很发达。

人口 

歐洲的人口約有7.28億人(2005年數據)，約占世界總人口的11%。其平均人口密度居各大洲的第一位。目前歐洲各國多面臨生育率下降及人口老化的問題，而推行各種政策以使人口正常成長。

來源：UNPP

民族及語言 

欧洲各民族主要是属于印欧语系语言的民族（超过90%的欧洲居民），最为广泛使用的有波罗的语族、罗曼语族、日尔曼语族、斯拉夫语族、凯尔特语族以及阿尔巴尼亚语、希腊语，也有从东方迁徙过去的使用乌拉尔语系语言的各民族和古老的巴斯克民族，在俄罗斯的欧洲部分尚有一部分使用阿尔泰语系的民族。基本是以民族国家划分，有的生活在不同国家的操同一语言的人群承认属于同一民族，但有的不愿意承认，只强调自己是那一国家的人。

欧洲人分屬多個不同的語族，其中有：
 印欧语系
 波罗的语族：拉脱维亚语、立陶宛语
 罗曼语族：法语、加泰罗尼亚语、加里西亞語、罗马尼亚语、罗曼什语、葡萄牙语、西班牙语、意大利语
 日尔曼语族：冰岛语、丹麦语、德语、荷兰语、卢森堡语、挪威语、瑞典语、英语
 斯拉夫语族：白俄罗斯语、波兰语、波斯尼亚语、俄语、捷克语、克罗地亚语、马其顿语、塞尔维亚语、斯洛伐克语、斯洛文尼亚语、乌克兰语
 凯尔特语族：爱尔兰语、苏格兰语、威尔士语
 阿尔巴尼亚语
 希腊语
 印度－伊朗语族：羅姆語
 乌拉尔语系：
 芬兰-乌戈尔语族：爱沙尼亚语、芬兰语、匈牙利语
 阿爾泰语系：
 突厥語族：土耳其語、韃靼語、楚瓦什語、哈萨克语
 蒙古語族：卡爾梅克語
 亞非語系：馬爾他語、阿拉伯語、希伯來語
 孤立語言
 巴斯克語

關於歐盟成員國的語言使用，參見歐洲聯盟的語言。

教育与文化 

所有欧洲国家的公民都要接受义务教育，或者至少是接受某种教育培训。欧洲的义务教育大概从6、7岁开始，一直持续到15、16岁。在大多数欧洲国家，基础教育的时间大概只持续四到五年，而在少数国家，却需要七八年。基础教育完成之后，学生所继续接受教育的高一级的学校就有多种类型了，有继续为高等学校预先培养人才的文理中学，还有一些技工学校。与此同时，在许多国家还有许多很有名望的高等专科学校和综合性大学，接纳那些已经完成初中等教育的学生。在这种教育体制的促进下，几乎所有欧洲国家的文盲率都很低。

雕刻艺术建筑、美术、文学以及音乐都是在欧洲具有悠久历史的傳統事物。许多城市，比如倫敦、巴黎、维也纳、罗马、柏林以及莫斯科等，今天都是在作为首都的同时，也被视作该国的文化中心。此外，在许多城市还有很多重要的剧院、博物馆、交响乐团以及其他很重要的文化设施。

古代文化 
欧洲具有很深厚的文化底蕴。欧洲史前美术体现了欧洲旧石器时代、中石器时代和新石器时代的建筑、雕刻、绘画和工艺的成就，其中欧洲旧石器时代艺术是迄今所知人类最早的真正的艺术品。此外欧洲史前器具艺术具有很强的表现力，被学者们称之为活动艺术。

11～17世纪，欧洲中世纪大学的兴起奠定了现代高等教育的模式。

科学文化的交流与合作 
欧洲各国在科学、文化等方面的合作也很紧密。

在文化方面，1950年创立以西欧和地中海沿岸国家广播电视机构为主的欧洲广播联盟。1957年8月21日创立的欧洲新闻社联盟增进各国新闻社之间的交流与合作。

在科学技术方面，由法国、德国、比利时、瑞典、荷兰、丹麦、意大利、瑞士8个国家共同经营的欧洲南天天文台是位于南半球的大型综合性天文台，其研究课题几乎涉及天文学的各个领域。1973年由30多个国家建立的欧洲分子生物学实验室促进欧洲各国在分子生物学领域的迅速发展。1975年5月30日由欧洲多个国家组成的-{zh-hans:欧洲空间局; zh-hant:歐洲太空總署;}-在航天领域很有竞争力。

宗教 

欧洲的宗教中，72%主要是信仰基督宗教（包括天主教、基督新教以及东正教）。

8％是伊斯兰教，其中大多数在俄罗斯生活（两千五百万），除此之外，在土耳其（590万）、法国（550万）、德国（320万）、波斯尼亞和黑塞哥維那與阿尔巴尼亚（140－250万）以及意大利（110万）等欧洲广大地区都有穆斯林分布，西欧的穆斯林主要为移民。

仅有少于1％的欧洲居民信仰犹太教（将近200万人）。其他的宗教（如印度教、佛教等）也都仅有低于1％的信徒。

部分欧洲国家无宗教人口的比例相对较高。根据欧洲联盟2005年公布的调查结果，无宗教信仰人口比例，超过60%的有英国、法国、荷兰、瑞典等国，超过50%的有德国、比利时、瑞士、挪威等国，而低于10%的有罗马尼亚、土耳其等国，低于20%的有葡萄牙、希腊、波兰等国。

國際關係

歐洲與亞太 
歐洲部分國家在亞太各地曾建立廣大的殖民地，例如：英國擁有印度、新加坡、馬來西亞、緬甸和香港等；法國擁有印度支那，即今日中南半島東部地區；葡萄牙曾管治澳門、果阿邦和東帝汶；西班牙曾管治菲律賓；荷蘭曾擁有東印度群島，亦即今日的印尼。也因此東南亞國家與歐洲國家的關係非常深厚，由於這般深厚的關係，今日國際關係中，歐洲對於東南亞仍有一定程度的影響力；在曾受西班牙統治，以天主教為國教的菲律賓，教宗所指派的樞機主教亦有政治及社會上的影響力。東北亞的日本曾與德國、義大利在第二次世界大戰中組成軸心國，現在日本、韓國與歐洲各國主要是以經濟關係為主，政治上的結盟已漸次減少。

歐洲與中亞 
從17世紀開始到20世紀，中亞大部分地區成了俄羅斯帝國以及隨後的蘇聯的領土，大量東歐的斯拉夫人開始遷移到哈薩克斯坦和吉爾吉斯斯坦。蘇聯解體後，哈薩克斯坦和吉爾吉斯斯坦的斯拉夫人開始大規模遷移回俄羅斯，導致哈薩克斯坦和吉爾吉斯斯坦的俄羅斯族人口比例大大下滑。蘇聯對中亞地區的統治，帶來了工業化和大量基礎設施的建設，但也伴隨著對地方文化的壓制，集體化項目的失敗導致很多人死亡，長期以來，該地區的民族關係都很緊張，也出現了一些環境問題。

歐洲與中東（西亞） 
地理上，歐洲與中東（西亞）是近鄰，歷史上，歐洲與中東的關係一向緊張，基本上是由於兩者在宗教理念上的根本不同：歐洲大部份國家以基督宗教為主要信仰，而伊朗和阿拉伯國家多以伊斯蘭教為國教。中東多個地區曾經在20世紀初第一次世界大戰之後成為英國和法國的殖民地。

橫跨歐洲與小亞細亞的伊斯蘭教國家土耳其本身與傳統歐洲各國的關係就非常微妙，它地處亞歐交界處，且它曾經既滅亡拜占庭帝國，現在又極渴望加入歐盟。

歐美 
歐洲與美國雖然在文化、民風等各方面，有著濃厚的歷史淵源和聯繫，但大致上於二十世紀中葉，第二次世界大戰之後，美國和歐洲有一種較緊密的盟友關係。在此之前，由於美洲在17世紀時期，曾是歐洲國家流放異見人士和囚犯的地方，所以，在美國開國1786年的初期，與歐洲殖民主義者，尤其是曾經統治過美國的英國，有著對立的關係。其後由於美國和歐洲長時期實施政治互不干預的政策，兩者在18至19世紀各自發展。20世紀的兩次世界大戰，令歐洲元氣大傷，但美國經濟卻有高度增長，西歐諸國均需要美國的經濟援助，自然靠近美國。再加上东欧诸国加入社会主义阵营，因而与美国关系降落冰点。冷战时期，以苏联为首的社会主义阵营的威脅加强除东欧外其他欧洲国家与美国的亲密度。但是在冷战结束后，威脅消失，欧洲（主要是欧盟成员国）与美国的关系发生一些变化，欧洲更需要有自己的声音，因此某些欧洲国家在九一一事件、伊拉克问题、以巴冲突等方面与美国产生不同意见，甚至有较大的分歧，但是其根深柢固的盟友关系还将保持不变。英國卻在上述事件中更加靠攏美國，與美國結成極為堅定的同盟關係，但也遭人取笑這個美國原屬的殖民主幾乎反倒成了美國的附庸。西班牙、波蘭等在美伊第二次戰爭時對美國的強力支持，使得美國稱讚這些國家為新歐洲，但隨著恐怖份子對西班牙發動攻擊，西班牙已退出與美國間的盟約，自伊拉克撤軍。

歐非 
歐洲和北非的關係，跟她與中東的關係差不多，因為北非與歐洲隔地中海相望，而北非亦是伊斯蘭教國家地區。歷史上，只有中世紀時期，阿拉伯帝國曾經統治過西班牙、葡萄牙和法國南部。自歐洲殖民主義興起，非洲各地成為歐洲的殖民地，法國在中非、西非和北非建立的法屬西非洲殖民地，是非洲大陸當時最大的殖民地。歐洲殖民主義者在非洲爭奪自然資源，情況直至1950年代開始非洲國家各民族的獨立運動浪潮，多個國家紛紛獨立，才有所改進。歐洲和非洲亦循著經貿的方向發展。

歐澳 
跟美國一樣，歐洲開發澳大利亞的初期亦以流放囚犯的作用。但由於歐洲和澳大利亞在地理上相距甚遠，令到兩者有著各位發展的空間，但在經濟、文化和宗親的聯繫上，澳大利亞和歐洲仍然有著很緊密的聯繫。澳大利亚及新西兰的主要移民群种均来源于欧洲，与当地土著民族及其他移民发展大洋洲。

内部政策差异 
虽然不少世界各国各项数据排名（如GDP、进出口总额、奥运会奖牌等）都将欧盟作为一个类似于主权国家的整体来看待，欧洲一体化的程度确实领先全球，但不同的欧洲国家在某些领域的内部政策方面仍然存在着明显的差异。

宗教政策 
欧洲是除东亚以外全球世俗化程度最高的地区。欧洲大部分国家皆已不设国教，但挪威、冰岛、芬兰的宪法仍规定基督新教路德宗为国教或唯一享受国家补贴的宗教，希腊宪法仍规定东正教为国教。

货币政策 
丹麦、瑞典、波兰、匈牙利、捷克、罗马尼亚、保加利亚等欧盟成员国至今未加入欧元区。

刑罚政策 
欧洲大部分国家不设死刑但保留无期徒刑，西班牙、葡萄牙、塞尔维亚、克罗地亚不设无期徒刑，但罪行特别严重的犯罪分子可能会被累计判处几百年甚至上千年的超长刑期。

擁有死刑法律的只有白俄羅斯。

毒品政策 
荷兰是唯一一个明文规定吸食和买卖大麻合法的欧洲国家。法国、希腊、瑞典、挪威、芬兰等国对大麻实行严厉的管制，无论是吸食还是买卖皆为违法，也不允许将大麻作为处方药使用。其他欧洲国家大都禁止私人种植和买卖大麻，但英国、德国、西班牙、比利时和捷克允许使用从大麻中提炼出的某些成分制造处方药。

性交易政策 
俄罗斯、瑞典、挪威、冰岛及东欧部分国家禁止一切形式的性交易，德国、荷兰、瑞士、奥地利、匈牙利、希腊、土耳其允许开设妓院卖淫，其余的欧洲国家允许性交易但禁止有组织地卖淫。

同性恋政策 
西欧大部分国家允许进行同性婚姻登记，義大利、捷克等国家则允许同性之间建立同居民事关系但不提供同性婚姻的注册登记，波兰、斯洛伐克、保加利亚等大部分东欧国家明文规定婚姻只能是异性之间的民事关系。

参見 

 歐洲聯盟
 斯堪的纳维亚
 欧洲議會
 歐元區
 欧洲一体化
 欧洲美元
 歐洲共同體
 歐洲委員會

注释

参考资料

引用

来源 

 网页
 "Europe". The Columbia Gazetteer of the World Online . 2005.  New York: Columbia University Press.

外部連結 

 
 歐洲歷史上不同时期的地图 

Europe

name: CI
on: [push, pull_request]

# Ensure only read permission is granted
permissions:
  contents: read

jobs:
  test:
    name: Test
    runs-on: ${{ matrix.os }}
    strategy:
      matrix:
        include:
          - build: stable
            os: ubuntu-latest
            rust: stable
          - build: beta
            os: ubuntu-latest
            rust: beta
          - build: nightly
            os: ubuntu-latest
            rust: nightly
          - build: macos
            os: macos-latest
            rust: stable
          - build: win32
            os: windows-latest
            rust: stable-i686-pc-windows-msvc
          - build: win64
            os: windows-latest
            rust: stable-x86_64-pc-windows-msvc
          - build: mingw
            os: windows-latest
            rust: stable-x86_64-pc-windows-gnu
    steps:
    - uses: actions/checkout@0c366fd6a839edf440554fa01a7085ccba70ac98 # v6.0.2
      with:
        persist-credentials: false
    - uses: dtolnay/rust-toolchain@e97e2d8cc328f1b50210efc529dca0028893a2d9 # v1
      with:
        toolchain: ${{ matrix.rust }}
    - uses: taiki-e/install-action@0abfcd587b70a713fdaa7fb502c885e2112acb15 # v2.75.7
      with:
        tool: cargo-hack
    - run: cargo hack test --feature-powerset --exclude-features max_level_off,max_level_error,max_level_warn,max_level_info,max_level_debug,max_level_trace,release_max_level_off,release_max_level_error,release_max_level_warn,release_max_level_info,release_max_level_debug,release_max_level_trace
    - run: cargo run --verbose --manifest-path test_max_level_features/Cargo.toml
    - run: cargo run --verbose --manifest-path test_max_level_features/Cargo.toml --release

  check:
    name: Check Format and Clippy
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@0c366fd6a839edf440554fa01a7085ccba70ac98 # v6.0.2
      with:
        persist-credentials: false
    - uses: dtolnay/rust-toolchain@e97e2d8cc328f1b50210efc529dca0028893a2d9 # v1
      with:
        toolchain: stable
        components: clippy
    - run: cargo fmt -- --check
    - run: cargo fmt --manifest-path test_max_level_features/Cargo.toml -- --check
    - run: cargo clippy --verbose
    - run: cargo clippy --verbose --manifest-path test_max_level_features/Cargo.toml

  doc:
    name: Check Documentation
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@0c366fd6a839edf440554fa01a7085ccba70ac98 # v6.0.2
      with:
        persist-credentials: false
    - uses: dtolnay/rust-toolchain@e97e2d8cc328f1b50210efc529dca0028893a2d9 # v1
      with:
        toolchain: stable
    - name: Run rustdoc
      env:
        RUSTDOCFLAGS: "-D warnings"
      run: cargo doc --verbose --features std,kv,kv_std,kv_sval,kv_serde

  features:
    name: Feature check
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@0c366fd6a839edf440554fa01a7085ccba70ac98 # v6.0.2
        with:
          persist-credentials: false
      - uses: dtolnay/rust-toolchain@e97e2d8cc328f1b50210efc529dca0028893a2d9 # v1
        with:
          toolchain: nightly
      - run: cargo build --verbose -Z avoid-dev-deps --features kv
      - run: cargo build --verbose -Z avoid-dev-deps --features "kv std"
      - run: cargo build --verbose -Z avoid-dev-deps --features "kv kv_sval"
      - run: cargo build --verbose -Z avoid-dev-deps --features "kv kv_serde"
      - run: cargo build --verbose -Z avoid-dev-deps --features "kv kv_std"
      - run: cargo build --verbose -Z avoid-dev-deps --features "kv kv_sval kv_serde"

  minimalv:
    name: Minimal versions
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@0c366fd6a839edf440554fa01a7085ccba70ac98 # v6.0.2
        with:
          persist-credentials: false
      - uses: dtolnay/rust-toolchain@e97e2d8cc328f1b50210efc529dca0028893a2d9 # v1
        with:
          toolchain: nightly
      - run: cargo build --verbose -Z minimal-versions --features kv
      - run: cargo build --verbose -Z minimal-versions --features "kv std"
      - run: cargo build --verbose -Z minimal-versions --features "kv kv_sval"
      - run: cargo build --verbose -Z minimal-versions --features "kv kv_serde"
      - run: cargo build --verbose -Z minimal-versions --features "kv kv_std"
      - run: cargo build --verbose -Z minimal-versions --features "kv kv_sval kv_serde"

  msrv:
    name: MSRV
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@0c366fd6a839edf440554fa01a7085ccba70ac98 # v6.0.2
        with:
          persist-credentials: false
      - uses: dtolnay/rust-toolchain@e97e2d8cc328f1b50210efc529dca0028893a2d9 # v1
        with:
          components: clippy
          toolchain: "1.71"
      - uses: taiki-e/install-action@0abfcd587b70a713fdaa7fb502c885e2112acb15 # v2.75.7
        with:
          tool: cargo-hack
      - run: cargo hack test --feature-powerset --exclude-features max_level_off,max_level_error,max_level_warn,max_level_info,max_level_debug,max_level_trace,release_max_level_off,release_max_level_error,release_max_level_warn,release_max_level_info,release_max_level_debug,release_max_level_trace
      - run: cargo run --verbose --manifest-path test_max_level_features/Cargo.toml
      - run: cargo run --verbose --manifest-path test_max_level_features/Cargo.toml --release

  embedded:
    name: Embedded
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@0c366fd6a839edf440554fa01a7085ccba70ac98 # v6.0.2
        with:
          persist-credentials: false
      - uses: dtolnay/rust-toolchain@e97e2d8cc328f1b50210efc529dca0028893a2d9 # v1
        with:
          toolchain: stable
      - run: rustup target add thumbv6m-none-eabi riscv32imc-unknown-none-elf
      - run: cargo build --verbose --target=thumbv6m-none-eabi
      - run: cargo build --verbose --target=riscv32imc-unknown-none-elf

ดิมมูบอร์เกียร์ ( แปลว่า เมืองแห่งความมืด) เป็นวงดนตรีในแนวซิมโฟนิคแบล็กเมทัลจากประเทศนอร์เวย์ สามารถติดอันดับชาร์ตเพลงในประเทศกลุ่มสแกนดิเนเวียและในประเทศเยอรมนี และจัดได้ว่าเป็นวงแบล็กเมทัลที่ประสบความสำเร็จอย่างสูง

ดิมมูบอร์เกียร์ ในช่วงก่อตั้งนั้นเล่นดนตรีแนวแบล็กเมทัล ซึ่งต่อมาได้เปลี่ยนมาเล่นในแนวซิมโฟนิคแบล็กเมทัล

สมาชิกวง

สมาชิกวงปัจจุบัน
 Shagrath (Stian Thoresen)  - ร้องนำ (1993-ปัจจุบัน)
 Silenoz (Sven Atle Kopperud)  - กีต้าร์ (1993-ปัจจุบัน)
 Galder (Thomas Rune Andersen)  - กีต้าร์ (2000-ปัจจุบัน)
 Cyrus (Terje Andersen)  - กีต้าร์เบส (2011-ปัจจุบัน)
 Gerlioz (Geir Bratland)   - เสียงสังเคราะห์และคีย์บอร์ด (2011-ปัจจุบัน)
 Daray (Dariusz Brzozowski)   - กลอง (2008-ปัจจุบัน)

อดีตสมาชิก 
 Nicholas Barker - กลอง (1999-2005)
 Tjodalv - กลอง (1993-1999)
 Tony Laureano - กลอง (2004-2006)
 Astennu - กีตาร์ (1998-1999)
 Brynjard Tristan - กีต้าร์เบส (1993-1996)
 Nagash - กีต้าร์เบส (1996-1999)
 Stian Aarstad - คีย์บอร์ด (1993-1997)

ไทม์ไลน์

อัลบั้ม 
 Inn I Evighetens Morke (1994)
 For All Tid (1994, ออกอัลบั้มอีกครั้งในปี 1997)
 Stormblåst (1996)
 Devil's Path (1996)
 Enthrone Darkness Triumphant (1997; ออกอัลบั้มอีกครั้งในปี 2002)
 Godless Savage Garden (1998)
 Spiritual Black Dimensions (1999)
 Puritanical Euphoric Misanthropia (2001)
 Alive In Torment (2001)
 World Misanthropy CD (2002)
 Death Cult Armageddon (2003)
 Stormblåst (บันทึกเสียงใหม่)  (2005)
 In Sorte Diaboli  (2007)
 Abrahadabra  (2010)
Eonian (2018)

อ้างอิง 

กลุ่มดนตรีแบล็กเมทัล
กลุ่มดนตรีสัญชาตินอร์เวย์
กลุ่มดนตรีที่ก่อตั้งในปี พ.ศ. 2536

{
  "name": "pallets/click",
  "image": "mcr.microsoft.com/devcontainers/python:3",
  "customizations": {
    "vscode": {
      "settings": {
        "python.defaultInterpreterPath": "${workspaceFolder}/.venv",
        "python.terminal.activateEnvInCurrentTerminal": true,
        "python.terminal.launchArgs": [
          "-X",
          "dev"
        ]
      }
    }
  },
  "onCreateCommand": ".devcontainer/on-create-command.sh"
}

#![cfg(feature = "serde_core")]

use serde_core::de::{
    Deserialize, DeserializeSeed, Deserializer, EnumAccess, Error, Unexpected, VariantAccess,
    Visitor,
};
use serde_core::ser::{Serialize, Serializer};

use crate::{Level, LevelFilter, LOG_LEVEL_NAMES};

use std::fmt;
use std::str::{self, FromStr};

// The Deserialize impls are handwritten to be case-insensitive using FromStr.

impl Serialize for Level {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        match *self {
            Level::Error => serializer.serialize_unit_variant("Level", 0, "ERROR"),
            Level::Warn => serializer.serialize_unit_variant("Level", 1, "WARN"),
            Level::Info => serializer.serialize_unit_variant("Level", 2, "INFO"),
            Level::Debug => serializer.serialize_unit_variant("Level", 3, "DEBUG"),
            Level::Trace => serializer.serialize_unit_variant("Level", 4, "TRACE"),
        }
    }
}

impl<'de> Deserialize<'de> for Level {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        struct LevelIdentifier;

        impl<'de> Visitor<'de> for LevelIdentifier {
            type Value = Level;

            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
                formatter.write_str("log level")
            }

            fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
            where
                E: Error,
            {
                let variant = LOG_LEVEL_NAMES[1..]
                    .get(v as usize)
                    .ok_or_else(|| Error::invalid_value(Unexpected::Unsigned(v), &self))?;

                self.visit_str(variant)
            }

            fn visit_str<E>(self, s: &str) -> Result<Self::Value, E>
            where
                E: Error,
            {
                // Case-insensitive.
                FromStr::from_str(s).map_err(|_| Error::unknown_variant(s, &LOG_LEVEL_NAMES[1..]))
            }

            fn visit_bytes<E>(self, value: &[u8]) -> Result<Self::Value, E>
            where
                E: Error,
            {
                let variant = str::from_utf8(value)
                    .map_err(|_| Error::invalid_value(Unexpected::Bytes(value), &self))?;

                self.visit_str(variant)
            }
        }

        impl<'de> DeserializeSeed<'de> for LevelIdentifier {
            type Value = Level;

            fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
            where
                D: Deserializer<'de>,
            {
                deserializer.deserialize_identifier(LevelIdentifier)
            }
        }

        struct LevelEnum;

        impl<'de> Visitor<'de> for LevelEnum {
            type Value = Level;

            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
                formatter.write_str("log level")
            }

            fn visit_enum<A>(self, value: A) -> Result<Self::Value, A::Error>
            where
                A: EnumAccess<'de>,
            {
                let (level, variant) = value.variant_seed(LevelIdentifier)?;
                // Every variant is a unit variant.
                variant.unit_variant()?;
                Ok(level)
            }
        }

        deserializer.deserialize_enum("Level", &LOG_LEVEL_NAMES[1..], LevelEnum)
    }
}

impl Serialize for LevelFilter {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        match *self {
            LevelFilter::Off => serializer.serialize_unit_variant("LevelFilter", 0, "OFF"),
            LevelFilter::Error => serializer.serialize_unit_variant("LevelFilter", 1, "ERROR"),
            LevelFilter::Warn => serializer.serialize_unit_variant("LevelFilter", 2, "WARN"),
            LevelFilter::Info => serializer.serialize_unit_variant("LevelFilter", 3, "INFO"),
            LevelFilter::Debug => serializer.serialize_unit_variant("LevelFilter", 4, "DEBUG"),
            LevelFilter::Trace => serializer.serialize_unit_variant("LevelFilter", 5, "TRACE"),
        }
    }
}

impl<'de> Deserialize<'de> for LevelFilter {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        struct LevelFilterIdentifier;

        impl<'de> Visitor<'de> for LevelFilterIdentifier {
            type Value = LevelFilter;

            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
                formatter.write_str("log level filter")
            }

            fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
            where
                E: Error,
            {
                let variant = LOG_LEVEL_NAMES
                    .get(v as usize)
                    .ok_or_else(|| Error::invalid_value(Unexpected::Unsigned(v), &self))?;

                self.visit_str(variant)
            }

            fn visit_str<E>(self, s: &str) -> Result<Self::Value, E>
            where
                E: Error,
            {
                // Case-insensitive.
                FromStr::from_str(s).map_err(|_| Error::unknown_variant(s, &LOG_LEVEL_NAMES))
            }

            fn visit_bytes<E>(self, value: &[u8]) -> Result<Self::Value, E>
            where
                E: Error,
            {
                let variant = str::from_utf8(value)
                    .map_err(|_| Error::invalid_value(Unexpected::Bytes(value), &self))?;

                self.visit_str(variant)
            }
        }

        impl<'de> DeserializeSeed<'de> for LevelFilterIdentifier {
            type Value = LevelFilter;

            fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
            where
                D: Deserializer<'de>,
            {
                deserializer.deserialize_identifier(LevelFilterIdentifier)
            }
        }

        struct LevelFilterEnum;

        impl<'de> Visitor<'de> for LevelFilterEnum {
            type Value = LevelFilter;

            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
                formatter.write_str("log level filter")
            }

            fn visit_enum<A>(self, value: A) -> Result<Self::Value, A::Error>
            where
                A: EnumAccess<'de>,
            {
                let (level_filter, variant) = value.variant_seed(LevelFilterIdentifier)?;
                // Every variant is a unit variant.
                variant.unit_variant()?;
                Ok(level_filter)
            }
        }

        deserializer.deserialize_enum("LevelFilter", &LOG_LEVEL_NAMES, LevelFilterEnum)
    }
}

#[cfg(test)]
mod tests {
    use crate::{Level, LevelFilter};
    use serde_test::{assert_de_tokens, assert_de_tokens_error, assert_tokens, Token};

    fn level_token(variant: &'static str) -> Token {
        Token::UnitVariant {
            name: "Level",
            variant,
        }
    }

    fn level_bytes_tokens(variant: &'static [u8]) -> [Token; 3] {
        [
            Token::Enum { name: "Level" },
            Token::Bytes(variant),
            Token::Unit,
        ]
    }

    fn level_variant_tokens(variant: u32) -> [Token; 3] {
        [
            Token::Enum { name: "Level" },
            Token::U32(variant),
            Token::Unit,
        ]
    }

    fn level_filter_token(variant: &'static str) -> Token {
        Token::UnitVariant {
            name: "LevelFilter",
            variant,
        }
    }

    fn level_filter_bytes_tokens(variant: &'static [u8]) -> [Token; 3] {
        [
            Token::Enum {
                name: "LevelFilter",
            },
            Token::Bytes(variant),
            Token::Unit,
        ]
    }

    fn level_filter_variant_tokens(variant: u32) -> [Token; 3] {
        [
            Token::Enum {
                name: "LevelFilter",
            },
            Token::U32(variant),
            Token::Unit,
        ]
    }

    #[test]
    fn test_level_ser_de() {
        let cases = &[
            (Level::Error, [level_token("ERROR")]),
            (Level::Warn, [level_token("WARN")]),
            (Level::Info, [level_token("INFO")]),
            (Level::Debug, [level_token("DEBUG")]),
            (Level::Trace, [level_token("TRACE")]),
        ];

        for (s, expected) in cases {
            assert_tokens(s, expected);
        }
    }

    #[test]
    fn test_level_case_insensitive() {
        let cases = &[
            (Level::Error, [level_token("error")]),
            (Level::Warn, [level_token("warn")]),
            (Level::Info, [level_token("info")]),
            (Level::Debug, [level_token("debug")]),
            (Level::Trace, [level_token("trace")]),
        ];

        for (s, expected) in cases {
            assert_de_tokens(s, expected);
        }
    }

    #[test]
    fn test_level_de_bytes() {
        let cases = &[
            (Level::Error, level_bytes_tokens(b"ERROR")),
            (Level::Warn, level_bytes_tokens(b"WARN")),
            (Level::Info, level_bytes_tokens(b"INFO")),
            (Level::Debug, level_bytes_tokens(b"DEBUG")),
            (Level::Trace, level_bytes_tokens(b"TRACE")),
        ];

        for (value, tokens) in cases {
            assert_de_tokens(value, tokens);
        }
    }

    #[test]
    fn test_level_de_variant_index() {
        let cases = &[
            (Level::Error, level_variant_tokens(0)),
            (Level::Warn, level_variant_tokens(1)),
            (Level::Info, level_variant_tokens(2)),
            (Level::Debug, level_variant_tokens(3)),
            (Level::Trace, level_variant_tokens(4)),
        ];

        for (value, tokens) in cases {
            assert_de_tokens(value, tokens);
        }
    }

    #[test]
    fn test_level_de_error() {
        let msg = "unknown variant `errorx`, expected one of \
                   `ERROR`, `WARN`, `INFO`, `DEBUG`, `TRACE`";
        assert_de_tokens_error::<Level>(&[level_token("errorx")], msg);
    }

    #[test]
    fn test_level_filter_ser_de() {
        let cases = &[
            (LevelFilter::Off, [level_filter_token("OFF")]),
            (LevelFilter::Error, [level_filter_token("ERROR")]),
            (LevelFilter::Warn, [level_filter_token("WARN")]),
            (LevelFilter::Info, [level_filter_token("INFO")]),
            (LevelFilter::Debug, [level_filter_token("DEBUG")]),
            (LevelFilter::Trace, [level_filter_token("TRACE")]),
        ];

        for (s, expected) in cases {
            assert_tokens(s, expected);
        }
    }

    #[test]
    fn test_level_filter_case_insensitive() {
        let cases = &[
            (LevelFilter::Off, [level_filter_token("off")]),
            (LevelFilter::Error, [level_filter_token("error")]),
            (LevelFilter::Warn, [level_filter_token("warn")]),
            (LevelFilter::Info, [level_filter_token("info")]),
            (LevelFilter::Debug, [level_filter_token("debug")]),
            (LevelFilter::Trace, [level_filter_token("trace")]),
        ];

        for (s, expected) in cases {
            assert_de_tokens(s, expected);
        }
    }

    #[test]
    fn test_level_filter_de_bytes() {
        let cases = &[
            (LevelFilter::Off, level_filter_bytes_tokens(b"OFF")),
            (LevelFilter::Error, level_filter_bytes_tokens(b"ERROR")),
            (LevelFilter::Warn, level_filter_bytes_tokens(b"WARN")),
            (LevelFilter::Info, level_filter_bytes_tokens(b"INFO")),
            (LevelFilter::Debug, level_filter_bytes_tokens(b"DEBUG")),
            (LevelFilter::Trace, level_filter_bytes_tokens(b"TRACE")),
        ];

        for (value, tokens) in cases {
            assert_de_tokens(value, tokens);
        }
    }

    #[test]
    fn test_level_filter_de_variant_index() {
        let cases = &[
            (LevelFilter::Off, level_filter_variant_tokens(0)),
            (LevelFilter::Error, level_filter_variant_tokens(1)),
            (LevelFilter::Warn, level_filter_variant_tokens(2)),
            (LevelFilter::Info, level_filter_variant_tokens(3)),
            (LevelFilter::Debug, level_filter_variant_tokens(4)),
            (LevelFilter::Trace, level_filter_variant_tokens(5)),
        ];

        for (value, tokens) in cases {
            assert_de_tokens(value, tokens);
        }
    }

    #[test]
    fn test_level_filter_de_error() {
        let msg = "unknown variant `errorx`, expected one of \
                   `OFF`, `ERROR`, `WARN`, `INFO`, `DEBUG`, `TRACE`";
        assert_de_tokens_error::<LevelFilter>(&[level_filter_token("errorx")], msg);
    }
}

<!doctype html>
<html lang="en">
  <head>
    <meta charset="utf-8">
    <title>lodash Performance Suite</title>
    <style>
      html, body {
        margin: 0;
        padding: 0;
        height: 100%;
      }
      #FirebugUI {
        top: 2.5em;
      }
      #perf-toolbar {
        background-color: #EEE;
        color: #5E740B;
        font-family: "Helvetica Neue Light", "HelveticaNeue-Light", "Helvetica Neue", Calibri, Helvetica, Arial, sans-serif;
        font-size: small;
        padding: 0.5em 1em 0.5em 1em;
        overflow: hidden;
      }
      #perf-toolbar label {
        display: inline-block;
        margin-right: 0.5em;
      }
      #perf-toolbar span {
        display: inline-block;
        float: right;
        line-height: 2.1em;
        margin-left: 1em;
        margin-top: 0;
      }
    </style>
  </head>
  <body>
    <div id="perf-toolbar"></div>
    <script src="../lodash.js"></script>
    <script src="../node_modules/platform/platform.js"></script>
    <script src="../node_modules/benchmark/benchmark.js"></script>
    <script src="../vendor/firebug-lite/src/firebug-lite-debug.js"></script>
    <script src="./asset/perf-ui.js"></script>
    <script>
      document.write('<script src="' + ui.buildPath + '"><\/script>');
    </script>
    <script>
      var lodash = _.noConflict();
    </script>
    <script>
      document.write('<script src="' + ui.otherPath + '"><\/script>');
    </script>
    <script src="perf.js"></script>
    <script>
      (function() {
        var measured,
            perfNow,
            begin = new Date;

        function init() {
          var fbUI = document.getElementById('FirebugUI'),
              fbDoc = fbUI && (fbDoc = fbUI.contentWindow || fbUI.contentDocument).document || fbDoc,
              fbCommandLine = fbDoc && fbDoc.getElementById('fbCommandLine');

          if (!fbCommandLine) {
            return setTimeout(init, 15);
          }
          fbUI.style.height = (
            Math.max(document.documentElement.clientHeight, document.body.clientHeight) -
            document.getElementById('perf-toolbar').clientHeight
          ) + 'px';

          fbDoc.body.style.height = fbDoc.documentElement.style.height = '100%';
          setTimeout(run, 15);
        }

        window.onload = init;
      }());
    </script>
  </body>
</html>

Bali (juga dikenal sebagai Kepulauan Bali, ) adalah sebuah wilayah provinsi yang terletak di Indonesia. Ibu kotanya adalah Denpasar. Provinsi Bali terletak di bagian barat Kepulauan Nusa Tenggara. Di awal kemerdekaan Indonesia, pulau ini termasuk dalam Provinsi Sunda Kecil yang beribu kota di Singaraja, dan kini terbagi menjadi 3 provinsi, yakni Bali, Nusa Tenggara Barat, dan Nusa Tenggara Timur . Pada tahun 2020, penduduk provinsi Bali berjumlah 4.317.404 jiwa, dengan kepadatan 747 jiwa/km2.

Selain terdiri dari pulau Bali, wilayah provinsi Bali juga terdiri dari pulau-pulau yang lebih kecil di sekitarnya, yaitu pulau Nusa Penida, pulau Nusa Lembongan, pulau Nusa Ceningan, Pulau Serangan, dan Pulau Menjangan. Secara geografis, Bali terletak di antara Pulau Jawa dan Pulau Lombok. Mayoritas penduduk Bali adalah pemeluk agama Hindu. Di dunia, Bali terkenal sebagai tujuan pariwisata dengan keunikan berbagai hasil seni-budayanya dan juga mitosnya, khususnya bagi para wisatawan Jepang dan Australia. Bali juga dikenal dengan julukan Pulau Dewata dan Pulau Seribu Pura.

Geografi 

Pulau Bali adalah bagian dari Kepulauan Sunda Kecil sepanjang 153 km dan selebar 112 km sekitar 3,2 km dari Pulau Jawa. Secara geografis, Bali terletak di 8°25′23″ Lintang Selatan dan 115°14′55″ Bujur Timur yang membuatnya beriklim tropis seperti bagian Indonesia yang lain.

Gunung Agung adalah titik tertinggi di Bali setinggi 3.148 m. Gunung berapi ini terakhir meletus pada Maret 1963. Gunung Batur juga salah satu gunung yang ada di Bali. Sekitar 30.000 tahun yang lalu, Gunung Batur meletus dan menghasilkan bencana yang dahsyat di bumi. Berbeda dengan di bagian utara, bagian selatan Bali adalah dataran rendah yang dialiri sungai-sungai.

Berdasarkan relief dan topografi, di tengah-tengah Pulau Bali terbentang pegunungan yang memanjang dari barat ke timur dan di antara pegunungan tersebut terdapat gugusan gunung berapi yaitu Gunung Batur dan Gunung Agung serta gunung yang tidak berapi, yaitu Gunung Merbuk, Gunung Patas dan Gunung Seraya. Adanya pegunungan tersebut menyebabkan Daerah Bali secara Geografis terbagi menjadi 2 (dua) bagian yang tidak sama yaitu Bali Utara dengan dataran rendah yang sempit dan kurang landai dan Bali Selatan dengan dataran rendah yang luas dan landai. 

Kemiringan lahan Pulau Bali terdiri dari lahan datar (0-2%) seluas 122.652 ha, lahan bergelombang (2-15%) seluas 118.339 ha, lahan curam (15-40%) seluas 190.486 ha dan lahan sangat curam (>40%) seluas 132.189 ha. Provinsi Bali memiliki 4 (empat) buah danau yang berlokasi di daerah pegunungan, yaitu Danau Beratan atau Bedugul, Buyan, Tamblingan, dan Batur. Alam Bali yang indah menjadikan pulau Bali terkenal sebagai daerah wisata.

Ibu kota Bali adalah Denpasar. Tempat-tempat penting lainnya adalah Ubud sebagai pusat kesenian dan peristirahatan, terletak di Kabupaten Gianyar. Nusa Lembongan adalah sebagai salah satu tempat menyelam (diving), terletak di Kabupaten Klungkung. Sedangkan Kuta, Seminyak, Jimbaran dan Nusa Dua adalah beberapa tempat yang menjadi tujuan utama pariwisata, baik wisata pantai maupun tempat peristirahatan, spa, dan lain-lain, terletak di Kabupaten Badung.

Luas wilayah Provinsi Bali adalah 5.636,66 km2 atau 0,29% luas wilayah Negara Kesatuan Republik Indonesia. Secara administratif Provinsi Bali terbagi atas 8 kabupaten, 1 kotamadya, 55 kecamatan, dan 701 desa/kelurahan.

Batas wilayah

Sejarah 

Jepang menduduki Bali selama Perang Dunia II dan saat itu seorang perwira militer bernama I Gusti Ngurah Rai membentuk pasukan Bali 'pejuang kemerdekaan'. Menyusul menyerahnya Jepang di Pasifik pada bulan Agustus 1945, Belanda segera kembali ke Indonesia (termasuk Bali) untuk menegakkan kembali pemerintahan kolonialnya layaknya keadaan sebelum perang. Hal ini ditentang oleh pasukan perlawanan Bali yang saat itu menggunakan senjata Jepang.

Pada 20 November 1946, pecahlah pertempuran Puputan Margarana yang terjadi di Uma Kaang, Desa Marga, Kabupaten Tabanan, Bali. Kolonel I Gusti Ngurah Rai yang berusia 29 tahun, memimpin tentaranya dari wilayah timur Bali untuk melakukan serangan sampai mati pada pasukan Belanda yang bersenjata lengkap. Seluruh anggota batalion Bali tersebut tewas  dan menjadikannya sebagai perlawanan militer Bali yang terakhir.

Pada tahun 1946, Belanda menjadikan Bali sebagai salah satu dari 13 wilayah bagian dari Negara Indonesia Timur yang baru diproklamasikan, yaitu sebagai salah satu negara saingan bagi Republik Indonesia yang diproklamasikan dan dikepalai oleh Sukarno dan Hatta. Bali kemudian juga dimasukkan ke dalam Republik Indonesia Serikat ketika Belanda mengakui kemerdekaan Indonesia pada 29 Desember 1949. Tahun 1950, secara resmi Bali meninggalkan perserikatannya dengan Belanda dan secara hukum menjadi sebuah provinsi dari Republik Indonesia.

Letusan Gunung Agung yang terjadi pada tahun 1963, sempat mengguncangkan perekonomian rakyat dan menyebabkan banyak penduduk Bali bertransmigrasi ke berbagai wilayah lain di Indonesia.

Tahun 1965, seiring dengan gagalnya kudeta oleh G30S terhadap pemerintah nasional di Jakarta, Bali dan banyak daerah lainnya, terjadilah penumpasan terhadap anggota dan simpatisan Partai Komunis Indonesia. Di Bali, diperkirakan lebih dari 100.000 orang terbunuh atau hilang. Meskipun demikian, kejadian-kejadian pada masa awal Orde Baru tersebut sampai dengan saat ini belum berhasil diungkapkan secara hukum.

Serangan teroris telah terjadi pada 12 Oktober 2002, berupa serangan Bom Bali I di kawasan pariwisata Kuta tepatnya Legian, menyebabkan sebanyak 202 orang tewas dan 209 orang lainnya cedera. Serangan Bom Bali II tahun 2005 juga terjadi tiga tahun kemudian di Kuta dan pantai Jimbaran. Kejadian-kejadian tersebut mendapat liputan internasional yang luas karena sebagian besar korbannya adalah wisatawan asing dan menyebabkan industri pariwisata Bali menghadapi tantangan berat beberapa tahun terakhir ini.

Pemerintahan

Gubernur 

Gubernur menjadi pejabat tertinggi di pemerintahan provinsi Bali. Gubernur Bali bertanggungjawab atas wilayah Provinsi Bali. Saat ini, gubernur atau kepala daerah yang menjabat di provinsi Bali ialah I Wayan Koster, didampingi wakil gubernur Tjokorda Oka Artha Ardana Sukawati atau sering disapa Cok Ace. Mereka menang pada Pemilihan umum Gubernur Bali 2018. Wayan Koster merupakan gubernur Bali yang ke-9, sejak provinsi ini dibentuk menjadi provinsi Bali tahun 1958 berdasarkan Undang-undang Nomor 64 Tahun 1958. Koster dan Cok Ace dilantik oleh presiden Republik Indonesia Joko Widodo, di Istana Negara Jakarta pada 5 September 2018, untuk masa jabatan 2018-2023.

Dewan Perwakilan Rakyat

Dewan Perwakilan Daerah 
Empat anggota DPD (2019-2024) dari Provinsi Bali adalah;
 Shri I.G.N. Arya Wedakarna M Wedasteraputra S
 I Made Mangku Pastika
 Anak Agung Gde Agung
 Bambang Santoso

Berdasarkan hasil Pemilihan Umum Legislatif 2019, Bali mengirimkan sembilan anggota DPR ke DPR RI. Pada tingkat provinsi, DPRD Bali dengan 55 kursi tersedia dikuasai oleh PDI-P dengan 33 kursi, disusul Partai Golkar dengan 8 kursi, dan Partai Gerindra dengan 6 kursi.

Daftar kabupaten dan kota di Bali

Demografi

Agama  

Berdasarkan data Badan Pusat Statistik (BPS) provinsi Bali tahun 2021, penduduk Bali berjumlah 4.317.404 jiwa (2020) dengan mayoritas etnis Bali. Data Kementerian Agama mencatat bahwa 86,70% warga provinsi Bali menganut agama Hindu. Agama lainnya adalah Islam sebanyak 10,10%, kemudian Kristen Protestan sebanyak 1,67%, Katolik sebanyak 0,83%, Budha sebanyak 0,68%, Konghucu sebanyak 0,01%, dan penganut kepercayaan kurang dari 0,01%.

Masyarakat suku Bali umumnya beragama Hindu. Sementara penduduk Jawa, Sunda, Sasak, Melayu, umumnya beragama Islam, dan beberapa orang asli suku Bali juga ada yang memeluk agama Islam. Sementara pemeluk agama Kristen umumnya berasal dari penduduk Nusa Tenggara Timur, kemudian Papua, suku Batak, Minahasa, Tionghoa. Dan ada juga satu desa yakni desa Blimbing Sari di kecamatan Melaya Jembrana, tidak jauh dari Pelabuhan Gilimanuk, sebuah desa Kristen di mana warganya adalah asli suku Bali, bahkan gerejanya bentuknya mirip Pura.

Suku bangsa 

Mayoritas penduduk yang mendiami provinsi Bali adalah suku asli setempat, yakni Bali. Suku Bali memiliki kekayaan budaya yang dikenal dunia, sehingga Bali menjadi tujuan utama wisatawan asing ke Indonesia. Selain kekayaan pantai, budaya yang diminati di Bali adalah tari-tariannya, seperti tari Kecak, festival seperti Ogoh-ogoh, dan lainnya. Suku terbanyak dari luar suku Bali adalah suku Jawa.

Berdasarkan data dari Sensus Penduduk Indonesia 2010, berikut ini komposisi etnis atau suku bangsa di provinsi Bali:

Bahasa 

Selain dari sektor pariwisata, penduduk Bali juga hidup dari pertanian dan perikanan, yang paling dikenal dunia dari pertanian di Bali ialah sistem Subak. Sebagian juga memilih menjadi seniman. Bahasa yang digunakan di Bali adalah bahasa Indonesia, Bali dan Inggris khususnya bagi yang bekerja di sektor pariwisata.

Bahasa Bali dan bahasa Indonesia adalah bahasa yang paling luas pemakaiannya di Bali dan sebagaimana penduduk Indonesia lainnya, sebagian besar masyarakat Bali adalah bilingual atau bahkan trilingual. Meskipun terdapat beberapa dialek dalam bahasa Bali, umumnya masyarakat Bali menggunakan sebentuk bahasa Bali pergaulan sebagai pilihan dalam berkomunikasi. Secara tradisi, penggunaan berbagai dialek bahasa Bali ditentukan berdasarkan sistem catur warna dalam agama Hindu Dharma dan keanggotan klan (istilah Bali: soroh, gotra); meskipun pelaksanaan tradisi tersebut cenderung berkurang.

Bahasa Inggris adalah bahasa ketiga (dan bahasa asing utama) bagi banyak masyarakat Bali yang dipengaruhi oleh kebutuhan yang besar dari industri pariwisata. Para karyawan yang bekerja pada pusat-pusat informasi wisatawan di Bali, sering kali juga memahami beberapa bahasa asing dengan kompetensi yang cukup memadai. Bahasa Jepang juga menjadi prioritas pendidikan di Bali.

Masyarakat Bali menggunakan bahasa Bali sebagai bahasa komunikasi antar sesama orang Bali selain bahasa Indonesia dan bahasa Inggris. Bahasa Bali merupakan subkelompok dari rumpun bahasa Austronesia Barat, dipergunakan oleh sekitar tiga juta penutur. Bahasa Bali memiliki fungsi dan kedudukan yang penting dalam kehidupan masyarakat Bali terutama pada topik-topik pembicaraan yang bersifat tradisional seperti pembicaraan masalah adat (dalam rapat atau pertemuan yang disebut sangkep) kebudayaan dan agama (Hindu).

Bahasa Bali terdiri atas dua dialek:
 Dialek Bali Aga atau Bali Mula yang dituturkan oleh penduduk Bali di daerah dataran tinggi di Bali
 Dialek Bali Dataran yang dituturkan oleh penduduk yang pada umumnya berdiam di daerah dataran rendah di Bali.

Masyarakat yang menggunakan dialek Bali Aga disebut masyarakat Bali Aga dan bermukim di wilayah pegunungan. Daerah pengguna dialek Bali Aga meliputi Kabupaten Karangasem, yaitu di Desa Tenganan, Kecamatan Manggis dan Desa Seraya, Kecamatan Karangasem; Kabupaten Bangli, yaitu di Desa Terunyan dan Kecamatan Kintamani; Kabupaten Klungkung, yaitu di Desa Klumpu, Kecamatan Nusa Penida; Kabupaten Badung bagian utara, yaitu di Kecamatan  Petang; Kabupaten Tabanan, yaitu di Desa Wongaya Gede, Kecamatan Penebel; Kabupaten Buleleng, yaitu di Desa Sepang, Kecamatan Busung Biu; Kabupaten Jembrana, yaitu di Desa Nusasari, Kecamatan Melaya. Selain itu, bahasa Bali juga dituturkan di berbagai daerah lainnya di Indonesia, yakni di Nusa Tenggara Barat, Lampung, Sulawesi Tenggara, Jawa Timur dan Kalimantan Tengah khususnya di Kabupaten Kapuas.

Dialek Bali Dataran digunakan oleh masyarakat Bali yang bertempat tinggal di daerah pesisir atau dataran rendah di Bali, baik di bagian utara Bali maupun bagian selatan Bali. Dialek Bali Dataran menyebar hampir di seluruh wilayah di Bali. Adapun wilayah yang menggunakan dialek bali dataran seperti Kabupaten Klungkung dari wilayah utara di kecamatan Banjarangkan yaitu Desa Bumbungan; Kabupaten Jembrana, yaitu desa Pengragoan, kecamatan Pekutatan; Kabupaten Tabanan, yaitu di desa Bantas, kecamatan Selemadeg Timur dan desa Luwus, kecamatan Baturiti; Kabupaten Badung, yaitu di desa Baha, kecamatan Mengwi dan Desa Pecatu, Kecamatan Kuta Selatan; Kota Denpasar yaitu di Kampung Kepoan, Desa Pemogan, Kecamatan Denpasar Selatan; Kabupaten Gianyar, yaitu di Desa Pupuan, Kecamatan Tegalalang dan Desa Saba, Kecamatan Blahbatuh; Kabupaten Klungkung, yaitu di Kampung Toyapakeh, Kecamatan Nusa Penida dan Kampung Gelgel, Kecamatan Klungkung; Kabupaten Karangasem, yaitu di Desa Bebandem dan Kampung Kecicang Muslim, Desa Bungaya Kangin,  Kecamatan Bebanden serta Desa Tianyar, Kecamatan Kubu; Kabupaten Bangli, yaitu di Desa Jehem, Kecamatan Tembuku; Kabupaten Buleleng, yaitu di Desa Bukti, Kecamatan Kubutambahan, Desa Pegayaman, Kecamatan Sukasada, Desa Kayu Putih, Kecamatan Banjar, dan Desa Banyupoh, Kecamatan Gerokgak.

Bahasa Bali mengenal sistem sor singgih atau tingkatan-tingkatan berbahasa terutama bahasa Bali Dataran karena mendapatkan pengaruh dari Jawa. Tingkatan-tingkatan berbahasa tersebut masih dipertahankan hingga kini oleh masyarakata Bali terutama dalam ranah-ranah tradisional. Sistem Pelapisan sosial masyarakat Bali yang dikenal dengan catur warna sangat besar pengaruhnya terhadap penggunaan Bahasa Bali. Masing-masing kelas sosial dalam masyarakat Bali akan menggunakan bahasa Bali sesuai dengan siapa yang diajak bicara. Seorang sudra akan berbicara dengan bahasa Bali halus kepada seseorang dari kasta brahmana.

Bahasa Bali terus mengalami perkembangan terutama bahasa Bali dataran yang disebut sebagai bahasa bali standar. Berdasarkan hasil keputusan Pesamuhan Agung Bahasa Bali yang diadakan tahun 1974 bahasa Bali standar atau baku digunakan oleh masyarakat Bali dalam sekolah-sekolah, pertemuan-pertemuan, surat menyurat, kesusastraan, media massa elektronik dan cetak, adat dan budaya. Bahasa Bali baku ini mengacu pada bahasa yang digunakan oleh masyarakat tutur bahasa Bali yang berdomisili di Klungkung dan kota Singaraja, hal ini disebabkan karena kedua wilayah ini cukup lama menjadi pusat kekuasaan politik, ekonomi dan kebudayaan Bali. Selain itu, bahasa Bali di kedua daerah tersebut memiliki ciri yang sama baik secara fonologis maupun sintaksis.

Terdapat perbedaan yang cukup kentara dari bahasa Bali yang dituturkan di luar Bali dengan yang dituturkan di daerah Bali dan dari dialek Bali Aga dengan dialek Bali Dataran. Berdasarkan perhitungan dialektometri, persentase perbedaan yang terukur antara dialek Bali Aga dengan dialek Bali Dataran adalah sebesar 60%. Jika ditinjau lebih luas lagi terhadap daerah luar Bali, isolek Bali yang berada di pulau Bali memiliki perbedaan sebesar 71,75% dengan bahasa Bali di Nusa Tenggara Barat; sebesar 69,5% jika dibandingkan dengan bahasa Bali di Jawa Timur; sebesar 77,5% jika dibandingkan dengan bahasa Bali di Lampung; dan sebesar 76,75% jika dibandingkan dengan bahasa Bali di Sulawesi Tenggara.

Ekonomi 

Tiga dekade lalu, perekonomian Bali sebagian besar mengandalkan dan berbasis pada pertanian baik dari segi output dan kesempatan kerja. Sekarang, industri pariwisata menjadi objek pendapatan terbesar bagi Bali. Hasilnya, Bali menjadi salah satu daerah terkaya di Indonesia. Pada tahun 2003, sekitar 80% perekonomian Bali bergantung pada industri pariwisata. Pada akhir Juni 2011, non-performing loan dari semua bank di Bali adalah 2,23%, lebih rendah dari rata-rata non-performing loan industri perbankan Indonesia (sekitar 5%). Ekonomi, bagaimanapun menderita secara signifikan sebagai akibat dari Bom Bali I tahun 2002 dan Bom Bali II tahun 2005. Industri pariwisata sendiri telah pulih dari akibat peristiwa ini. Pasca terjadinya Pandemi Covid-19 akhir tahun 2019, perekonomian Bali yang didominasi sektor Pariwisata, mengalami penurunan. Akan tetapi, sektor pertanian menjadi salah satu penopang utama perekonomian di provinsi Bali.

Pariwisata 

Bali adalah primadona pariwisata Indonesia yang sudah terkenal di seluruh dunia. Selain terkenal dengan keindahan alam, terutama pantainya, Bali juga terkenal dengan kesenian dan budayanya yang unik dan menarik. Industri pariwisata berpusat di Bali Selatan dan di beberapa daerah lainnya. Lokasi wisata yang utama adalah Kuta dan sekitarnya seperti Legian dan Seminyak, Sanur, Ubud, dan di daerah selatan seperti Jimbaran, Nusa Dua dan Pecatu.

Bali sebagai tempat tujuan wisata yang lengkap dan terpadu memiliki banyak sekali tempat wisata menarik, antara lain: Pantai Kuta, Pura Tanah Lot, Pantai Padang–Padang, Danau Beratan Bedugul, Garuda Wisnu Kencana (GWK), Pantai Lovina dengan Lumba Lumbanya, Pura Besakih, Uluwatu, Tegallalang, Ubud, Munduk, Kintamani, Amed, Tulamben, Pulau Menjangan dan masih banyak yang lainnya. Kini, Bali juga memiliki beberapa pusat wisata yang sarat edukasi untuk anak-anak seperti kebun binatang, museum tiga dimensi, taman bermain air, dan tempat penangkaran kura-kura.

Transportasi 

Bali tidak memiliki jaringan rel kereta api namun jaringan jalan yang ada di pulau ini tergolong sangat baik dibanding daerah-daerah lain di Indonesia, jaringan jalan tersedia dengan baik khususnya ke daerah-daerah tujuan wisatawan yakni Legian, Kuta, Sanur, Nusa Dua, Ubud, dll. Sebagian besar penduduk memiliki kendaraan pribadi dan memilih menggunakannya karena moda transportasi umum tidak tersedia dengan baik, kecuali taksi dan angkutan pariwisata. Moda transportasi massal saat ini disiapkan agar Bali mampu memberi kenyamanan lebih terhadap para wisatawan.

Sampai sekarang, transportasi di Bali umumnya dibangun di Bali bagian selatan sekitar Denpasar, Kuta, Nusa Dua, dan Sanur sedangkan wilayah utara kurang memiliki akomodasi yang baik.

Jenis kendaraan umum di Bali atara lain:
 Dokar, kendaraan dengan menggunakan kuda sebagai penarik dikenal sebagai delman di tempat lain.
 Ojek, taksi sepeda motor (sebagian sudah berbasis di intenet).
 Bemo/angkot, melayani dalam dan antarkota.
 Teman Bus yang melayani berbagai rute di wilayah sarbagita dan sekarang rencananya akan merambah daerah Bangli. 
 Taksi (sebagian sudah mempunyai aplikasi di smartphone).
 Komotra, bus yang melayani perjalanan ke kawasan pantai Kuta dan sekitarnya.
 Bus, melayani hubungan antarkota, pedesaan, dan antarprovinsi.

Bali terhubung dengan pulau Jawa dengan layanan kapal feri yang menghubungkan Pelabuhan Gilimanuk di kabupaten Jembrana dengan Pelabuhan Ketapang di Kabupaten Banyuwangi yang lama tempuhnya sekitar 30 hingga 45 menit saja. Penyeberangan ke Pulau Lombok melalui Pelabuhan Padangbai menuju Pelabuhan Lembar yang memakan waktu sekitar empat sampai lima jam lamanya tergantung cuaca.

Transportasi udara dilayani oleh Bandara Internasional Ngurah Rai dengan destinasi ke sejumlah kota besar di Indonesia, Australia, Singapura, Malaysia, Thailand, Timor Leste, RRC serta Jepang. Landas pacu dan pesawat terbang yang datang dan pergi bisa terlihat dengan jelas dari pantai dan menjadi semacam hiburan tambahan bagi para wisatawan yang menikmati pantai Bali.

Untuk transportasi darat antar pulau di bali ada terminal Ubung-Denpasar dan terminal Mengwi yang menghubungkan pulau Bali dengan Pulau Jawa dan Pulau Lombok. Terminal Ubung di pulau Bali ini melayani berbagai rute antar pulau tujuan Jakarta, Bandung, Semarang, Yogyakarta, Surabaya, Malang, Madura, Jember, dll. Angkutan antar pulau dilayani oleh armada bus besar dengan kelas ekonomi, bisnis dan eksekutif. Terminal Ubung relatif ramai mulai pukul 15.00–18.00 WITA karena pada jam tersebut banyak bus yang mulai berangkat ke kota tujuan masing-masing. Bagi anda yang datang ke terminal ini harap waspada karena banyak calo tiket yang agak memaksa penumpang.

Budaya

Rumah Adat 

Rumah Bali yang sesuai dengan aturan Asta Kosala Kosali (bagian Weda yang mengatur tata letak ruangan dan bangunan).

Menurut filosofi masyarakat Bali, kedinamisan dalam hidup akan tercapai apabila terwujudnya hubungan yang harmonis antara aspek pawongan, palemahan dan parahyangan. Untuk itu pembangunan sebuah rumah harus meliputi aspek-aspek tersebut atau yang biasa disebut Tri Hita Karana. Pawongan merupakan para penghuni rumah. Palemahan berarti harus ada hubungan yang baik antara penghuni rumah dan lingkungannya.

Pada umumnya bangunan atau arsitektur tradisional daerah Bali selalu dipenuhi hiasan, berupa ukiran, peralatan serta pemberian warna. Ragam hias tersebut mengandung arti tertentu sebagai ungkapan keindahan simbol-simbol dan penyampaian komunikasi. Bentuk-bentuk ragam hias dari jenis fauna juga berfungsi sebagai simbol-simbol ritual yang ditampilkan dalam patung.

Musik 

Musik tradisional Bali memiliki kesamaan dengan musik tradisional di banyak daerah lainnya di Indonesia, misalnya dalam penggunaan gamelan dan berbagai alat musik tabuh lainnya. Meskipun demikian, terdapat kekhasan dalam teknik memainkan dan gubahannya, misalnya dalam bentuk kecak, yaitu sebentuk nyanyian yang konon menirukan suara kera. Demikian pula beragam gamelan yang dimainkan, misalnya gamelan jegog, gamelan gong gede(gamelan jawa kuno), gamelan gambang, gamelan selunding dan gamelan Semar Pegulingan. Ada pula musik Angklung dimainkan untuk upacara ngaben serta musik Bebonangan dimainkan dalam berbagai upacara lainnya.

Terdapat bentuk modern dari musik tradisional Bali, misalnya Gamelan Gong Kebyar yang merupakan musik tarian yang dikembangkan pada masa penjajahan Belanda serta Joged Bumbung yang mulai populer di Bali sejak era tahun 1950-an. Umumnya musik Bali merupakan kombinasi dari berbagai alat musik perkusi metal (metalofon), gong dan perkusi kayu (xilofon). Karena hubungan sosial, politik dan budaya, musik tradisional Bali atau permainan gamelan gaya Bali memberikan pengaruh atau saling memengaruhi daerah budaya di sekitarnya, misalnya pada musik tradisional masyarakat Banyuwangi serta musik tradisional masyarakat Lombok.
 Gamelan
 Jegog
 Genggong
 Silat Bali

Tari 

Seni tari Bali pada umumnya dapat dikategorikan menjadi tiga kelompok, yaitu wali atau seni tari pertunjukan sakral, bebali atau seni tari pertunjukan untuk upacara dan juga untuk pengunjung dan balih-balihan atau seni tari untuk hiburan pengunjung.

Pakar seni tari Bali I Made Bandem pada awal tahun 1980-an pernah menggolongkan tari-tarian Bali tersebut; antara lain yang tergolong ke dalam wali misalnya Berutuk, Sang Hyang Dedari, Rejang dan Baris Gede, bebali antara lain ialah Gambuh, Topeng Pajegan dan Wayang Wong, sedangkan balih-balihan antara lain ialah Legong, Parwa, Arja, Prembon dan Joged serta berbagai koreografi tari modern lainnya.

Salah satu tarian yang sangat populer bagi para wisatawan ialah Tari Kecak dan Tari Pendet. Sekitar tahun 1930-an, Wayan Limbak bekerja sama dengan pelukis Jerman Walter Spies menciptakan tari Kecak berdasarkan tradisi Sang Hyang dan bagian-bagian kisah Ramayana. Wayan Limbak memopulerkan tari ini saat berkeliling dunia bersama rombongan penari Bali-nya.

Tarian wali 
 Sang Hyang Dedari
 Sang Hyang Jaran
 Tari Rejang
 Tari Baris

Tarian bebali 
 Tari Topeng
 Gambuh

Tarian balih-balihan 
 Tari Legong
 Arja
 Joged Bumbung
 Drama Gong
 Barong
 Tari Pendet
 Tari Kecak
 Calon Arang
 Tari Janger
 Tari Tenun

Pakaian daerah 
Pakaian daerah Bali sesungguhnya sangat bervariasi, meskipun secara selintas kelihatannya sama. Masing-masing daerah di Bali mempunyai ciri khas simbolik dan ornamen, berdasarkan kegiatan/upacara, jenis kelamin dan umur penggunanya. Status sosial dan ekonomi seseorang dapat diketahui berdasarkan corak busana dan ornamen perhiasan yang dipakainya.

Pria 

Busana tradisional pria umumnya terdiri dari:
 Udeng (ikat kepala)
 Kain kampuh
 Umpal (selendang pengikat)
 Kain wastra (kemben)
 Sabuk
 Keris
 Beragam ornamen perhiasan

Sering pula dikenakan baju kemeja, jas dan alas kaki sebagai pelengkap.

Wanita 

Busana tradisional wanita umumnya terdiri dari:
 Gelung (sanggul)
 Sesenteng (kemben songket)
 Kain wastra
 Sabuk prada (stagen), membelit pinggul dan dada
 Selendang songket bahu ke bawah
 Kain tapih atau sinjang, di sebelah dalam
 Beragam 

პრეზიდენტი — ტიტული, რომელსაც ატარებენ ქვეყნების, ორგანიზაციების, კომპანიების, სასწავლებლების პირველი პირები. ეტიმოლოგიურად პრეზიდენტი ნიშნავს პიროვნებას, რომელიც თავმჯდომარის ფუნქციას ასრულებს (ლათინურად: prae (წინ, თავში) + sedere (ჯდომა)). 

მისი თავდაპირველი მნიშვნელობა იყო შეხვედრების, ცერემონიების გაძღოლა, ამჟამად ის უპირატესად თანამდებობის პირთან ასოცირდება, რომელსაც აღმასრულებელი ხელისუფლება აქვს. პრეზიდენტის, როგორც სახელმწიფოს მეთაურის, ძალაუფლების ხარისხი ვარირებს ქვეყნიდან ქვეყანაში, ზოგიერთ ქვეყანაში მას დიდ ძალაუფლება აქვს მინიჭებული, მაგალითად აშშ-ში, საფრანგეთში, ზოგიერთში კი ნომინალური (გერმანია, იტალია).

იხილეთ აგრეთვე 

 საქართველოს პრეზიდენტი
 აზერბაიჯანის პრეზიდენტი
 აშშ-ის პრეზიდენტი
 გერმანიის პრეზიდენტი
 ესტონეთის პრეზიდენტი
 თურქეთის პრეზიდენტი
 ირანის პრეზიდენტი
 ისრაელის პრეზიდენტი
 ნიკარაგუის პრეზიდენტი
 რუსეთის პრეზიდენტი
 საფრანგეთის პრეზიდენტი
 სომხეთის პრეზიდენტი
 უკრაინის პრეზიდენტი
 ევროკომისიის პრეზიდენტი
 ევროპის პარლამენტის პრეზიდენტები

რესურსები ინტერნეტში
 

წოდებები

# Standalone Application with Briefcase

[Briefcase](https://briefcase.beeware.org/) is a tool for packaging Python
projects as standalone native applications. It can produce installers and
executables for macOS, Windows, and Linux that do not require the user to
install Python or any dependencies.

- Produces platform-native installers (``.pkg`` on macOS, ``.msi`` on
    Windows, ``.deb``/``.rpm`` on Linux).
- Bundles a Python interpreter and all dependencies.
- Supports passing command line arguments to the app.

This page outlines the basics of packaging a Click application with
Briefcase. Be sure to read its
[documentation](https://briefcase.beeware.org/en/stable/how-to/building/cli-apps/)
and use ``briefcase --help`` to understand what features are available.

## Installation

Install Briefcase in the virtual environment:

```console
pip install briefcase
```

## Configuration

Add a ``[tool.briefcase]`` section and a
``[tool.briefcase.app.<app-name>]`` section to ``pyproject.toml``.
Set ``console_app = true`` so Briefcase treats the project as a command
line application rather than a GUI application.

Given a Click application with the following project structure:

```text
hello-cli/
    src/
        hello_cli/
            __init__.py
            app.py
    LICENSE
    pyproject.toml
```

Where ``app.py`` contains a Click command:

```python
import click

@click.command()
@click.argument("name", default="World")
@click.option("--count", default=1, help="Number of times to greet.")
def main(name, count):
    """Greet someone by NAME (default: World)."""
    for _ in range(count):
        click.echo(f"Hello, {name}!")
```

Add the following Briefcase configuration to ``pyproject.toml``:

```toml
[tool.briefcase]
project_name = "Hello CLI"
bundle = "com.example"
version = "0.0.1"
url = "https://example.com/hello-cli"
license.file = "LICENSE"
author = "Your Name"
author_email = "you@example.com"

[tool.briefcase.app.hello-cli]
formal_name = "Hello CLI"
description = "My first application"
long_description = """More details about the app should go here.
"""
sources = [
    "src/hello_cli",
]
console_app = true
requires = [
    "click",
]
```

The key settings are:

- ``console_app = true`` -- tells Briefcase this is a terminal
    application, not a GUI.
- ``sources`` -- the list of source packages to include.
- ``requires`` -- the Python dependencies to bundle (Click and any other
    libraries the project needs).

## Entry Point

Briefcase launches the application by running the package with
``python -m <package>``, so a ``__main__.py`` file **must** exist in the
package. Without it, Briefcase will not be able to start the application.

Create ``__main__.py`` in the package directory and call the Click
command:

```python
from hello_cli.app import main

if __name__ == "__main__":
    main()
```

## Running

Use ``briefcase dev`` to run the application directly from the source
tree. Pass command line arguments after ``--``:

```console
$ briefcase dev -- World
Hello, World!
$ briefcase dev -- World --count 2
Hello, World!
Hello, World!
```

## Building and Packaging

To create a distributable executable, run the following commands:

```console
briefcase create
briefcase build
briefcase package
```

``briefcase create`` downloads a Python interpreter and installs
dependencies into an isolated app bundle. ``briefcase build`` compiles
the app, and ``briefcase package`` produces the final platform installer.

On macOS, this produces a ``.pkg`` installer. On Windows, it produces a
``.msi`` installer. On Linux, it produces a system package (``.deb``,
``.rpm``, etc.) for the current distribution.

Once installed, users can run the application directly from the terminal:

```console
$ hello-cli World
Hello, World!
$ hello-cli World --count 2
Hello, World!
Hello, World!
```

<a id="top"></a>
# Why do we need yet another C++ test framework?

Good question. For C++ there are quite a number of established frameworks,
including (but not limited to),
[Google Test](http://code.google.com/p/googletest/),
[Boost.Test](http://www.boost.org/doc/libs/1_49_0/libs/test/doc/html/index.html),
[CppUnit](http://sourceforge.net/apps/mediawiki/cppunit/index.php?title=Main_Page),
[Cute](http://www.cute-test.com), and
[many, many more](http://en.wikipedia.org/wiki/List_of_unit_testing_frameworks#C.2B.2B).

So what does Catch2 bring to the party that differentiates it from these? Apart from the catchy name, of course.


## Key Features

* Quick and easy to get started. Just download two files, add them into your project and you're away.
* No external dependencies. As long as you can compile C++14 and have the C++ standard library available.
* Write test cases as, self-registering, functions (or methods, if you prefer).
* Divide test cases into sections, each of which is run in isolation (eliminates the need for fixtures).
* Use BDD-style Given-When-Then sections as well as traditional unit test cases.
* Only one core assertion macro for comparisons. Standard C/C++ operators are used for the comparison - yet the full expression is decomposed and lhs and rhs values are logged.
* Tests are named using free-form strings - no more couching names in legal identifiers.


## Other core features

* Tests can be tagged for easily running ad-hoc groups of tests.
* Failures can (optionally) break into the debugger on common platforms.
* Output is through modular reporter objects. Basic textual and XML reporters are included. Custom reporters can easily be added.
* JUnit xml output is supported for integration with third-party tools, such as CI servers.
* A default main() function is provided, but you can supply your own for complete control (e.g. integration into your own test runner GUI).
* A command line parser is provided and can still be used if you choose to provide your own main() function.
* Alternative assertion macro(s) report failures but don't abort the test case
* Good set of facilities for floating point comparisons (`Catch::Approx` and full set of matchers)
* Internal and friendly macros are isolated so name clashes can be managed
* Data generators (data driven test support)
* Hamcrest-style Matchers for testing complex properties
* Microbenchmarking support


## Who else is using Catch2?

A whole lot of people. According to [the 2022 JetBrains C++ ecosystem survey](https://www.jetbrains.com/lp/devecosystem-2022/cpp/#Which-unit-testing-frameworks-do-you-regularly-use),
about 12% of C++ programmers use Catch2 for unit testing, making it the
second most popular unit testing framework.

You can also take a look at the (incomplete) list of [open source projects](opensource-users.md#top)
or the (very incomplete) list of [commercial users of Catch2](commercial-users.md#top)
for some idea on who else also uses Catch2.

---

See the [tutorial](tutorial.md#top) to get more of a taste of using
Catch2 in practice.

---

[Home](Readme.md#top)

Dr. Ing. h.c. F. Porsche AG, kısaca Porsche AG veya sadece Porsche (okunuşu: Porşe) 1947 yılında Ferdinand Porsche'nın oğlu Ferry Porsche tarafından Stuttgart'ta kurulmuş olan spor araba firmasıdır.

İlk modelleri 1948 yılında çıkan Porsche 356'dır. Ferdinand Porsche 356 tasarımını yaparken oğluna yardım etmiş ve 1951 yılında ölmüştür.

1963 yılında araba yarışlarında müthiş başarılar elde edecek Porsche 911'i piyasaya sunarlar. 6 silindirli, arkadan motorlu bir spor arabasıdır ve rallilerde de büyük başarılar kazanır.

Bu süre içerisinde Volkswagen ile yakınlaşılır.  Şirketin %30,9'u Volkswagen'e aittir. Birçok projede ortaklaşa çalışmalarda bulunurlar. (1969 VW-Porsche 914, 1976 Porsche 924 (Audi bazı parçaları kullanmıştır) ve 2002 Porsche Cayenne (motoru da başta olmak üzere birçok teknik aksamı ve ergonomik çizgileri Volkswagen Touareg'de kullanılmıştır). 2003 yılında Ferdinand Porsche'nin torunu, Ferdinand Piech Volkswagen'in CEO'su olarak bu iki şirketin "ailesel" anlamda birleşmesini sağlamıştır. Porsche, 1950-1963 yılları arasında Porsche Traktör adıyla traktör, 1987-1989 yılları arasında uçak motorları üretmiştir.

Porsche LeMans'ı 16 kez kazanmış, Formula 1'de McLaren'in motorunu yaratmış, Paris Dakar Rallisi'nin de zirvedeki isimlerinden biri olmuştur.

Volkswagen AG, Porsche'nin %52,2 hissesini satın almıştır.

Seat, Daewoo ve Subaru başta olmak üzere birçok otomotiv firması danışman olarak Porsche firmasıyla anlaşma yapmışlardır.

Modelleri

Hâlen üretilmekte olan modeller
 Porsche Taycan (2019-Günümüz)
 Porsche 918 Spyder (2013-Günümüz)
 Porsche Boxster (1996-Günümüz)
 Porsche Cayman (2006-Günümüz)
 Porsche 911 (1964-Günümüz)
 Porsche Panamera (2010-Günümüz)
 Porsche Cayenne (2004-Günümüz)
 Porsche 911 GT3 (1998-Günümüz)
Üretimden Kaldırılmış Modeller
 Porsche 356 (1948-1965)
 Porsche 550 Spyder (1953-1957)
 Porsche 912 (1965-1969)
 Porsche 914 (1969-1975)
 Porsche 924 (1976-1988)
 Porsche 928 (1978-1995)
 Porsche 944 (1982-1991)
 Porsche 959 (1986-1988)
 Porsche 968 (1992-1995)
 Porsche Carrera GT (2004-2006)

Yarış modelleri
 Porsche 64
 Porsche 360 Cisitalia
 Porsche 550 Spyder
 Porsche 718
 Porsche 804
 Porsche 904
 Porsche 906
 Porsche 907
 Porsche 908
 Porsche 909 Bergspyder
 Porsche 910
 Porsche 911
 Porsche 911 GT1
 Porsche 911 GT2
 Porsche 911 GT3
 Porsche 914
 Porsche 917
 Porsche 918 RSR
 Porsche 934
 Porsche 935
 Porsche 936
 Porsche 924
 Porsche 944
 Porsche 956
 Porsche 959
 Porsche 961
 Porsche-March 89 P
 Porsche RS Spyder

Motor sporlarında Porsche 
 14 Üreticiler ve Takımlar Dünya şampiyonluğu (1964, 1969, 1970, 1971, 1976, 1977, 1978, 1979, 1982, 1983, 1984, 1985, 1986, 1994)
 8 Uzun Mesafe Dünya Şampiyonluğu
 3 IMSA Supercar-Series (1991, 1992, 1993)
 6 Alman Yarış Şampiyonluğu (1977, 1979, 1982, 1983, 1984, 1985)
 20 Avrupa Tırmanış Şampiyonluğu
 20 Daytona 24 Saat Şampiyonluğu (1968, 1970, 1971, 1973, 1975, 1977, 1978, 1979, 1980, 1981, 1982, 1983, 1984, 1985, 1986, 1987, 1989, 1991, 1995, 2003)
 15 IMSA Supercar-Race (ABD)
 16 Le Mans 24 Saat (1970, 1971, 1976, 1977, 1979, 1981, 1982, 1983, 1984, 1985, 1986, 1987, 1994, 1996, 1997, 1998)
 17 Sebring 12 Saat (1960, 1968, 1971, 1973, 1976, 1977, 1978, 1979, 1980, 1981, 1982, 1983, 1984, 1985, 1986, 1987, 1988)
 11 Targa Florio (1956, 1959, 1960, 1963, 1964, 1966, 1967, 1968, 1969, 1970, 1973)
 4 Rallye Monte Carlo (1968, 1969, 1970, 1978)
 2 Paris-Dakar Rallisi (1984, 1986)
 1 Formula 1 zaferi (1962 Fransa Grand Prix)

TAG-Porsche motorlu McLaren otomobilleri 
 3 Formula 1 Pilotlar Dünya Şampiyonluğu (1984, 1985, 1986)
 2 Formula 1 üreticiler Dünya Şampiyonluğu (1984, 1985)
 25 Formula 1 zaferi (1984, 12 galibiyet; 1985, 6 galibiyet; 1986, 4 galibiyet; 1987, 3 galibiyet)

Notlar

Dış bağlantılar 
 Resmî Porsche web sitesi (Birçok dilde)
 Porsche Türkiye

1947'de kurulan şirketler
Stuttgart
Baden-Württemberg'te ekonomi
Almanya merkezli otomotiv şirketleri
Otomobil markaları
Otomobil üreticileri
Traktör üreticileri
Volkswagen grubu
Alman markaları
Lüks markalar

# Advanced Groups and Context

```{currentmodule} click
```

In addition to the capabilities covered in the previous section, Groups have
more advanced capabilities that leverage the Context.

```{contents}
---
depth: 1
local: true
---
```

## Callback Invocation

For a regular command, the callback is executed whenever the command runs.
If the script is the only command, it will always fire (unless a parameter
callback prevents it.  This for instance happens if someone passes
`--help` to the script).

For groups, the situation looks different. In this case, the callback fires
whenever a subcommand fires.  What this means in practice is that an outer
command runs when an inner command runs:

```{eval-rst}
.. click:example::

    @click.group()
    @click.option('--debug/--no-debug', default=False)
    def cli(debug):
        click.echo(f"Debug mode is {'on' if debug else 'off'}")

    @cli.command()  # @cli, not @click!
    def sync():
        click.echo('Syncing')

Here is what this looks like:

.. click:run::

    invoke(cli, prog_name='tool.py')
    println()
    invoke(cli, prog_name='tool.py', args=['--debug', 'sync'])
```

## Nested Handling and Contexts

As you can see from the earlier example, the basic command group accepts a
debug argument which is passed to its callback, but not to the sync
command itself.  The sync command only accepts its own arguments.

This allows tools to act completely independent of each other, but how
does one command talk to a nested one?  The answer to this is the
{class}`Context`.

Each time a command is invoked, a new context is created and linked with the
parent context.  Normally, you can't see these contexts, but they are
there.  Contexts are passed to parameter callbacks together with the
value automatically.  Commands can also ask for the context to be passed
by marking themselves with the {func}`pass_context` decorator.  In that
case, the context is passed as first argument.

The context can also carry a program specified object that can be
used for the program's purposes.  What this means is that you can build a
script like this:

```{eval-rst}
.. click:example::

    @click.group()
    @click.option('--debug/--no-debug', default=False)
    @click.pass_context
    def cli(ctx, debug):
        # ensure that ctx.obj exists and is a dict (in case `cli()` is called
        # by means other than the `if` block below)
        ctx.ensure_object(dict)

        ctx.obj['DEBUG'] = debug

    @cli.command()
    @click.pass_context
    def sync(ctx):
        click.echo(f"Debug is {'on' if ctx.obj['DEBUG'] else 'off'}")

    if __name__ == '__main__':
        cli(obj={})
```

If the object is provided, each context will pass the object onwards to
its children, but at any level a context's object can be overridden.  To
reach to a parent, `context.parent` can be used.

In addition to that, instead of passing an object down, nothing stops the
application from modifying global state.  For instance, you could just flip
a global `DEBUG` variable and be done with it.

## Decorating Commands

As you have seen in the earlier example, a decorator can change how a
command is invoked.  What actually happens behind the scenes is that
callbacks are always invoked through the {meth}`Context.invoke` method
which automatically invokes a command correctly (by either passing the
context or not).

This is very useful when you want to write custom decorators.  For
instance, a common pattern would be to configure an object representing
state and then storing it on the context and then to use a custom
decorator to find the most recent object of this sort and pass it as first
argument.

For instance, the {func}`pass_obj` decorator can be implemented like this:

```{eval-rst}
.. click:example::

    from functools import update_wrapper

    def pass_obj(f):
        @click.pass_context
        def new_func(ctx, *args, **kwargs):
            return ctx.invoke(f, ctx.obj, *args, **kwargs)
        return update_wrapper(new_func, f)
```

The {meth}`Context.invoke` command will automatically invoke the function
in the correct way, so the function will either be called with`f(ctx,
obj)` or `f(obj)` depending on whether or not it itself is decorated with
{func}`pass_context`.

This is a very powerful concept that can be used to build very complex
nested applications; see {ref}`complex-guide` for more information.

(command-chaining)=

## Command Chaining

It is useful to invoke more than one subcommand in one call. For example,
`my-app validate build upload` would invoke `validate`, then `build`, then
`upload`. To implement this, pass `chain=True` when creating a group.

```{eval-rst}
.. click:example::

    @click.group(chain=True)
    def cli():
        pass

    @cli.command('validate')
    def validate():
        click.echo('validate')

    @cli.command('build')
    def build():
        click.echo('build')

You can invoke it like this:

.. click:run::

    invoke(cli, prog_name='my-app', args=['validate', 'build'])
```

When using chaining, there are a few restrictions:

- Only the last command may use `nargs=-1` on an argument, otherwise the
  parser will not be able to find further commands.
- It is not possible to nest groups below a chain group.
- On the command line, options must be specified before arguments for each
  command in the chain.
- The {attr}`Context.invoked_subcommand` attribute will be `'*'` because the
  parser doesn't know the full list of commands that will run yet.

(command-pipelines)=

## Command Pipelines

When using chaining, a common pattern is to have each command process the
result of the previous command.

A straightforward way to do this is to use {func}`make_pass_decorator` to pass
a context object to each command, and store and read the data on that object.

```{eval-rst}
.. click:example::

    pass_ns = click.make_pass_decorator(dict, ensure=True)

    @click.group(chain=True)
    @click.argument("name")
    @pass_ns
    def cli(ns, name):
        ns["name"] = name

    @cli.command
    @pass_ns
    def lower(ns):
        ns["name"] = ns["name"].lower()

    @cli.command
    @pass_ns
    def show(ns):
        click.echo(ns["name"])

.. click:run::

    invoke(cli, prog_name="process", args=["Click", "show", "lower", "show"])
```

Another way to do this is to collect data returned by each command, then process
it at the end of the chain. Use the group's {meth}`~Group.result_callback`
decorator to register a function that is called after the chain is finished. It
is passed the list of return values as well as any parameters registered on the
group.

A command can return anything, including a function. Here's an example of that,
where each subcommand creates a function that processes the input, then the
result callback calls each function. The command takes a file, processes each
line, then outputs it. If no subcommands are given, it outputs the contents
of the file unchanged.

```python
@click.group(chain=True, invoke_without_command=True)
@click.argument("fin", type=click.File("r"))
def cli(fin):
    pass

@cli.result_callback()
def process_pipeline(processors, fin):
    iterator = (x.rstrip("\r\n") for x in input)

    for processor in processors:
        iterator = processor(iterator)

    for item in iterator:
        click.echo(item)

@cli.command("upper")
def make_uppercase():
    def processor(iterator):
        for line in iterator:
            yield line.upper()
    return processor

@cli.command("lower")
def make_lowercase():
    def processor(iterator):
        for line in iterator:
            yield line.lower()
    return processor

@cli.command("strip")
def make_strip():
    def processor(iterator):
        for line in iterator:
            yield line.strip()
    return processor
```

That's a lot in one go, so let's go through it step by step.

1. The first thing is to make a {func}`group` that is chainable.  In
   addition to that we also instruct Click to invoke even if no
   subcommand is defined.  If this would not be done, then invoking an
   empty pipeline would produce the help page instead of running the
   result callbacks.
2. The next thing we do is to register a result callback on our group.
   This callback will be invoked with an argument which is the list of
   all return values of all subcommands and then the same keyword
   parameters as our group itself.  This means we can access the input
   file easily there without having to use the context object.
3. In this result callback we create an iterator of all the lines in the
   input file and then pass this iterator through all the returned
   callbacks from all subcommands and finally we print all lines to
   stdout.

After that point we can register as many subcommands as we want and each
subcommand can return a processor function to modify the stream of lines.

One important thing of note is that Click shuts down the context after
each callback has been run.  This means that for instance file types
cannot be accessed in the `processor` functions as the files will already
be closed there.  This limitation is unlikely to change because it would
make resource handling much more complicated.  For such it's recommended
to not use the file type and manually open the file through
{func}`open_file`.

For a more complex example that also improves upon handling of the pipelines,
see the [imagepipe example](https://github.com/pallets/click/tree/main/examples/imagepipe)
in the Click repository. It implements a pipeline based image editing tool
that has a nice internal structure.

## Overriding Defaults

By default, the default value for a parameter is pulled from the
`default` flag that is provided when it's defined, but that's not the
only place defaults can be loaded from.  The other place is the
{attr}`Context.default_map` (a dictionary) on the context.  This allows
defaults to be loaded from a configuration file to override the regular
defaults.

This is useful if you plug in some commands from another package but
you're not satisfied with the defaults.

The default map can be nested arbitrarily for each subcommand:

```python

    default_map = {
        "debug": True,  # default for a top level option
        "runserver": {"port": 5000}  # default for a subcommand
    }
```

The default map can be provided when the script is invoked, or
overridden at any point by commands. For instance, a top-level command
could load the defaults from a configuration file.

Example usage:

```{eval-rst}
.. click:example::

    import click

    @click.group()
    def cli():
        pass

    @cli.command()
    @click.option('--port', default=8000)
    def runserver(port):
        click.echo(f"Serving on http://127.0.0.1:{port}/")

    if __name__ == '__main__':
        cli(default_map={
            'runserver': {
                'port': 5000
            }
        })

And in action:

.. click:run::

    invoke(cli, prog_name='cli', args=['runserver'], default_map={
        'runserver': {
            'port': 5000
        }
    })
```

### Multi-value parameters

When a `default_map` value is a string for a parameter with `nargs > 1` or a
{class}`Tuple` type, the string is split automatically, the same way an
environment variable would be. By default, values are split on whitespace. See
[Multiple Options from Environment
Values](options.md#multiple-options-from-environment-values) for details on
splitting behavior.

```python
default_map = {
    "draw": {
        "point": "3 4",  # split into ("3", "4") for nargs=2
        "color": "red",  # passed as-is for nargs=1
    }
}
```

You can also pass an already-structured tuple or list, which will be used as-is
without splitting:

```python
default_map = {
    "draw": {
        "point": (3, 4),  # used directly
    }
}
```

## Context Defaults

```{versionadded} 2.0
```

Starting with Click 2.0 you can override defaults for contexts not just
when calling your script, but also in the decorator that declares a
command.  For instance given the previous example which defines a custom
`default_map` this can also be accomplished in the decorator now.

This example does the same as the previous example:

```{eval-rst}
.. click:example::

    import click

    CONTEXT_SETTINGS = dict(
        default_map={'runserver': {'port': 5000}}
    )

    @click.group(context_settings=CONTEXT_SETTINGS)
    def cli():
        pass

    @cli.command()
    @click.option('--port', default=8000)
    def runserver(port):
        click.echo(f"Serving on http://127.0.0.1:{port}/")

    if __name__ == '__main__':
        cli()

And again the example in action:

.. click:run::

    invoke(cli, prog_name='cli', args=['runserver'])
```

## Command Return Values

```{versionadded} 3.0
```

One of the new introductions in Click 3.0 is the full support for return
values from command callbacks.  This enables a whole range of features
that were previously hard to implement.

In essence any command callback can now return a value.  This return value
is bubbled to certain receivers.  One usecase for this has already been
show in the example of {ref}`command-chaining` where it has been
demonstrated that chained groups can have callbacks that process
all return values.

When working with command return values in Click, this is what you need to
know:

- The return value of a command callback is generally returned from the
  {meth}`Command.invoke` method.  The exception to this rule has to
  do with {class}`Group`s:

  - In a group the return value is generally the return value of the
    subcommand invoked.  The only exception to this rule is that the
    return value is the return value of the group callback if it's
    invoked without arguments and `invoke_without_command` is enabled.
  - If a group is set up for chaining then the return value is a list
    of all subcommands' results.
  - Return values of groups can be processed through a
    {attr}`Group.result_callback`.  This is invoked with the
    list of all return values in chain mode, or the single return
    value in case of non chained commands.

- The return value is bubbled through from the {meth}`Context.invoke`
  and {meth}`Context.forward` methods.  This is useful in situations
  where you internally want to call into another command.

- Click does not have any hard requirements for the return values and
  does not use them itself.  This allows return values to be used for
  custom decorators or workflows (like in the command chaining
  example).

- When a Click script is invoked as command line application (through
  {meth}`Command.main`) the return value is ignored unless the
  `standalone_mode` is disabled in which case it's bubbled through.

'use strict'

var assert = require('node:assert');
var express = require('..');

describe('config', function () {
  describe('.set()', function () {
    it('should set a value', function () {
      var app = express();
      app.set('foo', 'bar');
      assert.equal(app.get('foo'), 'bar');
    })

    it('should set prototype values', function () {
      var app = express()
      app.set('hasOwnProperty', 42)
      assert.strictEqual(app.get('hasOwnProperty'), 42)
    })

    it('should return the app', function () {
      var app = express();
      assert.equal(app.set('foo', 'bar'), app);
    })

    it('should return the app when undefined', function () {
      var app = express();
      assert.equal(app.set('foo', undefined), app);
    })

    it('should return set value', function () {
      var app = express()
      app.set('foo', 'bar')
      assert.strictEqual(app.set('foo'), 'bar')
    })

    it('should return undefined for prototype values', function () {
      var app = express()
      assert.strictEqual(app.set('hasOwnProperty'), undefined)
    })

    describe('"etag"', function(){
      it('should throw on bad value', function(){
        var app = express();
        assert.throws(app.set.bind(app, 'etag', 42), /unknown value/);
      })

      it('should set "etag fn"', function(){
        var app = express()
        var fn = function(){}
        app.set('etag', fn)
        assert.equal(app.get('etag fn'), fn)
      })
    })

    describe('"trust proxy"', function(){
      it('should set "trust proxy fn"', function(){
        var app = express()
        var fn = function(){}
        app.set('trust proxy', fn)
        assert.equal(app.get('trust proxy fn'), fn)
      })
    })
  })

  describe('.get()', function(){
    it('should return undefined when unset', function(){
      var app = express();
      assert.strictEqual(app.get('foo'), undefined);
    })

    it('should return undefined for prototype values', function () {
      var app = express()
      assert.strictEqual(app.get('hasOwnProperty'), undefined)
    })

    it('should otherwise return the value', function(){
      var app = express();
      app.set('foo', 'bar');
      assert.equal(app.get('foo'), 'bar');
    })

    describe('when mounted', function(){
      it('should default to the parent app', function(){
        var app = express();
        var blog = express();

        app.set('title', 'Express');
        app.use(blog);
        assert.equal(blog.get('title'), 'Express');
      })

      it('should given precedence to the child', function(){
        var app = express();
        var blog = express();

        app.use(blog);
        app.set('title', 'Express');
        blog.set('title', 'Some Blog');

        assert.equal(blog.get('title'), 'Some Blog');
      })

      it('should inherit "trust proxy" setting', function () {
        var app = express();
        var blog = express();

        function fn() { return false }

        app.set('trust proxy', fn);
        assert.equal(app.get('trust proxy'), fn);
        assert.equal(app.get('trust proxy fn'), fn);

        app.use(blog);

        assert.equal(blog.get('trust proxy'), fn);
        assert.equal(blog.get('trust proxy fn'), fn);
      })

      it('should prefer child "trust proxy" setting', function () {
        var app = express();
        var blog = express();

        function fn1() { return false }
        function fn2() { return true }

        app.set('trust proxy', fn1);
        assert.equal(app.get('trust proxy'), fn1);
        assert.equal(app.get('trust proxy fn'), fn1);

        blog.set('trust proxy', fn2);
        assert.equal(blog.get('trust proxy'), fn2);
        assert.equal(blog.get('trust proxy fn'), fn2);

        app.use(blog);

        assert.equal(app.get('trust proxy'), fn1);
        assert.equal(app.get('trust proxy fn'), fn1);
        assert.equal(blog.get('trust proxy'), fn2);
        assert.equal(blog.get('trust proxy fn'), fn2);
      })
    })
  })

  describe('.enable()', function(){
    it('should set the value to true', function(){
      var app = express();
      assert.equal(app.enable('tobi'), app);
      assert.strictEqual(app.get('tobi'), true);
    })

    it('should set prototype values', function () {
      var app = express()
      app.enable('hasOwnProperty')
      assert.strictEqual(app.get('hasOwnProperty'), true)
    })
  })

  describe('.disable()', function(){
    it('should set the value to false', function(){
      var app = express();
      assert.equal(app.disable('tobi'), app);
      assert.strictEqual(app.get('tobi'), false);
    })

    it('should set prototype values', function () {
      var app = express()
      app.disable('hasOwnProperty')
      assert.strictEqual(app.get('hasOwnProperty'), false)
    })
  })

  describe('.enabled()', function(){
    it('should default to false', function(){
      var app = express();
      assert.strictEqual(app.enabled('foo'), false);
    })

    it('should return true when set', function(){
      var app = express();
      app.set('foo', 'bar');
      assert.strictEqual(app.enabled('foo'), true);
    })

    it('should default to false for prototype values', function () {
      var app = express()
      assert.strictEqual(app.enabled('hasOwnProperty'), false)
    })
  })

  describe('.disabled()', function(){
    it('should default to true', function(){
      var app = express();
      assert.strictEqual(app.disabled('foo'), true);
    })

    it('should return false when set', function(){
      var app = express();
      app.set('foo', 'bar');
      assert.strictEqual(app.disabled('foo'), false);
    })

    it('should default to true for prototype values', function () {
      var app = express()
      assert.strictEqual(app.disabled('hasOwnProperty'), true)
    })
  })
})

var app = require('../../examples/multi-router')
var request = require('supertest')

describe('multi-router', function(){
  describe('GET /',function(){
    it('should respond with root handler', function(done){
      request(app)
      .get('/')
      .expect(200, 'Hello from root route.', done)
    })
  })

  describe('GET /api/v1/',function(){
    it('should respond with APIv1 root handler', function(done){
      request(app)
      .get('/api/v1/')
      .expect(200, 'Hello from APIv1 root route.', done)
    })
  })

  describe('GET /api/v1/users',function(){
    it('should respond with users from APIv1', function(done){
      request(app)
      .get('/api/v1/users')
      .expect(200, 'List of APIv1 users.', done)
    })
  })

  describe('GET /api/v2/',function(){
    it('should respond with APIv2 root handler', function(done){
      request(app)
      .get('/api/v2/')
      .expect(200, 'Hello from APIv2 root route.', done)
    })
  })

  describe('GET /api/v2/users',function(){
    it('should respond with users from APIv2', function(done){
      request(app)
      .get('/api/v2/users')
      .expect(200, 'List of APIv2 users.', done)
    })
  })
})

from jinja2 import nodes
from jinja2.idtracking import symbols_for_node


def test_basics():
    for_loop = nodes.For(
        nodes.Name("foo", "store"),
        nodes.Name("seq", "load"),
        [nodes.Output([nodes.Name("foo", "load")])],
        [],
        None,
        False,
    )
    tmpl = nodes.Template(
        [nodes.Assign(nodes.Name("foo", "store"), nodes.Name("bar", "load")), for_loop]
    )

    sym = symbols_for_node(tmpl)
    assert sym.refs == {
        "foo": "l_0_foo",
        "bar": "l_0_bar",
        "seq": "l_0_seq",
    }
    assert sym.loads == {
        "l_0_foo": ("undefined", None),
        "l_0_bar": ("resolve", "bar"),
        "l_0_seq": ("resolve", "seq"),
    }

    sym = symbols_for_node(for_loop, sym)
    assert sym.refs == {
        "foo": "l_1_foo",
    }
    assert sym.loads == {
        "l_1_foo": ("param", None),
    }


def test_complex():
    title_block = nodes.Block(
        "title", [nodes.Output([nodes.TemplateData("Page Title")])], False, False
    )

    render_title_macro = nodes.Macro(
        "render_title",
        [nodes.Name("title", "param")],
        [],
        [
            nodes.Output(
                [
                    nodes.TemplateData('\n  <div class="title">\n    <h1>'),
                    nodes.Name("title", "load"),
                    nodes.TemplateData("</h1>\n    <p>"),
                    nodes.Name("subtitle", "load"),
                    nodes.TemplateData("</p>\n    "),
                ]
            ),
            nodes.Assign(
                nodes.Name("subtitle", "store"), nodes.Const("something else")
            ),
            nodes.Output(
                [
                    nodes.TemplateData("\n    <p>"),
                    nodes.Name("subtitle", "load"),
                    nodes.TemplateData("</p>\n  </div>\n"),
                    nodes.If(
                        nodes.Name("something", "load"),
                        [
                            nodes.Assign(
                                nodes.Name("title_upper", "store"),
                                nodes.Filter(
                                    nodes.Name("title", "load"),
                                    "upper",
                                    [],
                                    [],
                                    None,
                                    None,
                                ),
                            ),
                            nodes.Output(
                                [
                                    nodes.Name("title_upper", "load"),
                                    nodes.Call(
                                        nodes.Name("render_title", "load"),
                                        [nodes.Const("Aha")],
                                        [],
                                        None,
                                        None,
                                    ),
                                ]
                            ),
                        ],
                        [],
                        [],
                    ),
                ]
            ),
        ],
    )

    for_loop = nodes.For(
        nodes.Name("item", "store"),
        nodes.Name("seq", "load"),
        [
            nodes.Output(
                [
                    nodes.TemplateData("\n    <li>"),
                    nodes.Name("item", "load"),
                    nodes.TemplateData("</li>\n    <span>"),
                ]
            ),
            nodes.Include(nodes.Const("helper.html"), True, False),
            nodes.Output([nodes.TemplateData("</span>\n  ")]),
        ],
        [],
        None,
        False,
    )

    body_block = nodes.Block(
        "body",
        [
            nodes.Output(
                [
                    nodes.TemplateData("\n  "),
                    nodes.Call(
                        nodes.Name("render_title", "load"),
                        [nodes.Name("item", "load")],
                        [],
                        None,
                        None,
                    ),
                    nodes.TemplateData("\n  <ul>\n  "),
                ]
            ),
            for_loop,
            nodes.Output([nodes.TemplateData("\n  </ul>\n")]),
        ],
        False,
        False,
    )

    tmpl = nodes.Template(
        [
            nodes.Extends(nodes.Const("layout.html")),
            title_block,
            render_title_macro,
            body_block,
        ]
    )

    tmpl_sym = symbols_for_node(tmpl)
    assert tmpl_sym.refs == {
        "render_title": "l_0_render_title",
    }
    assert tmpl_sym.loads == {
        "l_0_render_title": ("undefined", None),
    }
    assert tmpl_sym.stores == {"render_title"}
    assert tmpl_sym.dump_stores() == {
        "render_title": "l_0_render_title",
    }

    macro_sym = symbols_for_node(render_title_macro, tmpl_sym)
    assert macro_sym.refs == {
        "subtitle": "l_1_subtitle",
        "something": "l_1_something",
        "title": "l_1_title",
        "title_upper": "l_1_title_upper",
    }
    assert macro_sym.loads == {
        "l_1_subtitle": ("resolve", "subtitle"),
        "l_1_something": ("resolve", "something"),
        "l_1_title": ("param", None),
        "l_1_title_upper": ("resolve", "title_upper"),
    }
    assert macro_sym.stores == {"title", "title_upper", "subtitle"}
    assert macro_sym.find_ref("render_title") == "l_0_render_title"
    assert macro_sym.dump_stores() == {
        "title": "l_1_title",
        "title_upper": "l_1_title_upper",
        "subtitle": "l_1_subtitle",
        "render_title": "l_0_render_title",
    }

    body_sym = symbols_for_node(body_block)
    assert body_sym.refs == {
        "item": "l_0_item",
        "seq": "l_0_seq",
        "render_title": "l_0_render_title",
    }
    assert body_sym.loads == {
        "l_0_item": ("resolve", "item"),
        "l_0_seq": ("resolve", "seq"),
        "l_0_render_title": ("resolve", "render_title"),
    }
    assert body_sym.stores == set()

    for_sym = symbols_for_node(for_loop, body_sym)
    assert for_sym.refs == {
        "item": "l_1_item",
    }
    assert for_sym.loads == {
        "l_1_item": ("param", None),
    }
    assert for_sym.stores == {"item"}
    assert for_sym.dump_stores() == {
        "item": "l_1_item",
    }


def test_if_branching_stores():
    tmpl = nodes.Template(
        [
            nodes.If(
                nodes.Name("expression", "load"),
                [nodes.Assign(nodes.Name("variable", "store"), nodes.Const(42))],
                [],
                [],
            )
        ]
    )

    sym = symbols_for_node(tmpl)
    assert sym.refs == {"variable": "l_0_variable", "expression": "l_0_expression"}
    assert sym.stores == {"variable"}
    assert sym.loads == {
        "l_0_variable": ("resolve", "variable"),
        "l_0_expression": ("resolve", "expression"),
    }
    assert sym.dump_stores() == {
        "variable": "l_0_variable",
    }


def test_if_branching_stores_undefined():
    tmpl = nodes.Template(
        [
            nodes.Assign(nodes.Name("variable", "store"), nodes.Const(23)),
            nodes.If(
                nodes.Name("expression", "load"),
                [nodes.Assign(nodes.Name("variable", "store"), nodes.Const(42))],
                [],
                [],
            ),
        ]
    )

    sym = symbols_for_node(tmpl)
    assert sym.refs == {"variable": "l_0_variable", "expression": "l_0_expression"}
    assert sym.stores == {"variable"}
    assert sym.loads == {
        "l_0_variable": ("undefined", None),
        "l_0_expression": ("resolve", "expression"),
    }
    assert sym.dump_stores() == {
        "variable": "l_0_variable",
    }


def test_if_branching_multi_scope():
    for_loop = nodes.For(
        nodes.Name("item", "store"),
        nodes.Name("seq", "load"),
        [
            nodes.If(
                nodes.Name("expression", "load"),
                [nodes.Assign(nodes.Name("x", "store"), nodes.Const(42))],
                [],
                [],
            ),
            nodes.Include(nodes.Const("helper.html"), True, False),
        ],
        [],
        None,
        False,
    )

    tmpl = nodes.Template(
        [nodes.Assign(nodes.Name("x", "store"), nodes.Const(23)), for_loop]
    )

    tmpl_sym = symbols_for_node(tmpl)
    for_sym = symbols_for_node(for_loop, tmpl_sym)
    assert for_sym.stores == {"item", "x"}
    assert for_sym.loads == {
        "l_1_x": ("alias", "l_0_x"),
        "l_1_item": ("param", None),
        "l_1_expression": ("resolve", "expression"),
    }

'use strict'
const express = require('../.');
const request = require('supertest');

describe('res', function () {
  describe('.status(code)', function () {

    it('should set the status code when valid', function (done) {
      var app = express();

      app.use(function (req, res) {
        res.status(200).end();
      });

      request(app)
        .get('/')
        .expect(200, done);
    });

    describe('accept valid ranges', function() {
      // not testing w/ 100, because that has specific meaning and behavior in Node as Expect: 100-continue
      it('should set the response status code to 101', function (done) {
        var app = express()

        app.use(function (req, res) {
          res.status(101).end()
        })

        request(app)
          .get('/')
          .expect(101, done)
      })

      it('should set the response status code to 201', function (done) {
        var app = express()

        app.use(function (req, res) {
          res.status(201).end()
        })

        request(app)
          .get('/')
          .expect(201, done)
      })

      it('should set the response status code to 302', function (done) {
        var app = express()

        app.use(function (req, res) {
          res.status(302).end()
        })

        request(app)
          .get('/')
          .expect(302, done)
      })

      it('should set the response status code to 403', function (done) {
        var app = express()

        app.use(function (req, res) {
          res.status(403).end()
        })

        request(app)
          .get('/')
          .expect(403, done)
      })

      it('should set the response status code to 501', function (done) {
        var app = express()

        app.use(function (req, res) {
          res.status(501).end()
        })

        request(app)
          .get('/')
          .expect(501, done)
      })

      it('should set the response status code to 700', function (done) {
        var app = express()

        app.use(function (req, res) {
          res.status(700).end()
        })

        request(app)
          .get('/')
          .expect(700, done)
      })

      it('should set the response status code to 800', function (done) {
        var app = express()

        app.use(function (req, res) {
          res.status(800).end()
        })

        request(app)
          .get('/')
          .expect(800, done)
      })

      it('should set the response status code to 900', function (done) {
        var app = express()

        app.use(function (req, res) {
          res.status(900).end()
        })

        request(app)
          .get('/')
          .expect(900, done)
      })
    })

    describe('invalid status codes', function () {
      it('should raise error for status code below 100', function (done) {
        var app = express();

        app.use(function (req, res) {
          res.status(99).end();
        });

        request(app)
          .get('/')
          .expect(500, /Invalid status code/, done);
      });

      it('should raise error for status code above 999', function (done) {
        var app = express();

        app.use(function (req, res) {
          res.status(1000).end();
        });

        request(app)
          .get('/')
          .expect(500, /Invalid status code/, done);
      });

      it('should raise error for non-integer status codes', function (done) {
        var app = express();

        app.use(function (req, res) {
          res.status(200.1).end();
        });

        request(app)
          .get('/')
          .expect(500, /Invalid status code/, done);
      });

      it('should raise error for undefined status code', function (done) {
        var app = express();

        app.use(function (req, res) {
          res.status(undefined).end();
        });

        request(app)
          .get('/')
          .expect(500, /Invalid status code/, done);
      });

      it('should raise error for null status code', function (done) {
        var app = express();

        app.use(function (req, res) {
          res.status(null).end();
        });

        request(app)
          .get('/')
          .expect(500, /Invalid status code/, done);
      });

      it('should raise error for string status code', function (done) {
        var app = express();

        app.use(function (req, res) {
          res.status("200").end();
        });

        request(app)
          .get('/')
          .expect(500, /Invalid status code/, done);
      });

      it('should raise error for NaN status code', function (done) {
        var app = express();

        app.use(function (req, res) {
          res.status(NaN).end();
        });

        request(app)
          .get('/')
          .expect(500, /Invalid status code/, done);
      });
    });
  });
});

'use strict'

/**
 * Module dependencies.
 */

var createError = require('http-errors')
var express = require('../../');
var app = module.exports = express();

// Faux database

var users = [
  { name: 'tj' }
  , { name: 'tobi' }
  , { name: 'loki' }
  , { name: 'jane' }
  , { name: 'bandit' }
];

// Convert :to and :from to integers

app.param(['to', 'from'], function(req, res, next, num, name){
  req.params[name] = parseInt(num, 10);
  if( isNaN(req.params[name]) ){
    next(createError(400, 'failed to parseInt '+num));
  } else {
    next();
  }
});

// Load user by id

app.param('user', function(req, res, next, id){
  req.user = users[id]
  if (req.user) {
    next();
  } else {
    next(createError(404, 'failed to find user'));
  }
});

/**
 * GET index.
 */

app.get('/', function(req, res){
  res.send('Visit /user/0 or /users/0-2');
});

/**
 * GET :user.
 */

app.get('/user/:user', function (req, res) {
  res.send('user ' + req.user.name);
});

/**
 * GET users :from - :to.
 */

app.get('/users/:from-:to', function (req, res) {
  var from = req.params.from;
  var to = req.params.to;
  var names = users.map(function(user){ return user.name; });
  res.send('users ' + names.slice(from, to + 1).join(', '));
});

/* istanbul ignore next */
if (!module.parent) {
  app.listen(3000);
  console.log('Express started on port 3000');
}

<div align="center">
	<br>
	<br>
	<img width="360" src="media/logo.svg" alt="Got">
	<br>
	<br>
	<br>
	<br>
	<hr>
	<p>
		<p>
			<sup>
				Sindre's open source work is supported by the community.<br>Special thanks to:
			</sup>
		</p>
		<br>
		<br>
		<a href="https://www.fame.fi#gh-light-mode-only">
			<img src="https://sindresorhus.com/assets/thanks/fame-logo-light.svg" width="200" alt="Fame Helsinki">
		</a>
		<a href="https://www.fame.fi#gh-dark-mode-only">
			<img src="https://sindresorhus.com/assets/thanks/fame-logo-dark.svg" width="200" alt="Fame Helsinki">
		</a>
		<br>
		<br>
		<br>
		<br>
		<a href="https://depot.dev?utm_source=github&utm_medium=sindresorhus">
			<div>
				<picture>
					<source width="180" media="(prefers-color-scheme: dark)" srcset="https://sindresorhus.com/assets/thanks/depot-logo-dark.svg">
					<source width="180" media="(prefers-color-scheme: light)" srcset="https://sindresorhus.com/assets/thanks/depot-logo-light.svg">
					<img width="180" src="https://sindresorhus.com/assets/thanks/depot-logo-light.svg" alt="Depot logo">
				</picture>
			</div>
			<b>Fast remote container builds and GitHub Actions runners.</b>
		</a>
		<br>
		<br>
		<br>
	</p>
	<hr>
	<br>
	<br>
	<br>
	<br>
	<br>
	<br>
	<br>
</div>

> Human-friendly and powerful HTTP request library for Node.js

<!-- [![Coverage Status](https://codecov.io/gh/sindresorhus/got/branch/main/graph/badge.svg)](https://codecov.io/gh/sindresorhus/got/branch/main) -->
[![Downloads](https://img.shields.io/npm/dm/got.svg)](https://npmjs.com/got)
[![Install size](https://packagephobia.com/badge?p=got)](https://packagephobia.com/result?p=got)

[See how Got compares to other HTTP libraries](#comparison)

---

**You probably want [Ky](https://github.com/sindresorhus/ky) instead, by the same people. It's smaller, works in the browser too, and is more stable since it's built on [`Fetch`](https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API). Or [fetch-extras](https://github.com/sindresorhus/fetch-extras) for simple needs.**

---

**Support questions should be asked [here](https://github.com/sindresorhus/got/discussions).**

## Install

```sh
npm install got
```

**Warning:** This package is native [ESM](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Modules) and no longer provides a CommonJS export. If your project uses CommonJS, you will have to [convert to ESM](https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c). Please don't open issues for questions regarding CommonJS / ESM.

**Got v11 is no longer maintained and we will not accept any backport requests.**

## Take a peek

**A [quick start](documentation/quick-start.md) guide is available.**

### JSON mode

Got has a dedicated option for handling JSON payload.\
Furthermore, the promise exposes a `.json<T>()` function that returns `Promise<T>`.

```js
import got from 'got';

const {data} = await got.post('https://httpbin.org/anything', {
	json: {
		hello: 'world'
	}
}).json();

console.log(data);
//=> {"hello": "world"}
```

For advanced JSON usage, check out the [`parseJson`](documentation/2-options.md#parsejson) and [`stringifyJson`](documentation/2-options.md#stringifyjson) options.

**For more useful tips like this, visit the [Tips](documentation/tips.md) page.**

## Highlights

- [Used by 10K+ packages and 5M+ repos](https://github.com/sindresorhus/got/network/dependents)
- [Actively maintained](https://github.com/sindresorhus/got/graphs/contributors)
- [Trusted by many companies](#widely-used)

## Documentation

By default, Got will retry on failure. To disable this option, set [`options.retry.limit`](documentation/7-retry.md#retry) to 0.

#### Main API

- [x] [Promise API](documentation/1-promise.md)
- [x] [Options](documentation/2-options.md)
- [x] [Stream API](documentation/3-streams.md)
- [x] [Pagination API](documentation/4-pagination.md)
- [x] [Advanced HTTPS API](documentation/5-https.md)
- [x] [HTTP/2 support](documentation/2-options.md#http2)
- [x] [`Response` class](documentation/3-streams.md#response-2)

#### Timeouts and retries

- [x] [Advanced timeout handling](documentation/6-timeout.md)
- [x] [Retries on failure](documentation/7-retry.md)
- [x] [Errors with metadata](documentation/8-errors.md)

#### Advanced creation

- [x] [Hooks](documentation/9-hooks.md)
- [x] [Instances](documentation/10-instances.md)
- [x] [Progress events & other events](documentation/3-streams.md#events)
- [x] [Plugins](documentation/lets-make-a-plugin.md)
- [x] [Compose](documentation/examples/advanced-creation.js)

#### Cache, Proxy and UNIX sockets

- [x] [RFC 7234 compliant caching](documentation/cache.md)
- [x] [Proxy support](documentation/tips.md#proxying)
- [x] [Unix Domain Sockets](documentation/2-options.md#enableunixsockets)

#### Integration

- [x] [Diagnostics Channel](documentation/diagnostics-channel.md)
- [x] [TypeScript support](documentation/typescript.md)
- [x] [AWS](documentation/tips.md#aws)
- [x] [Testing](documentation/tips.md#testing)

---

### Migration guides

- [Request migration guide](documentation/migration-guides/request.md)
  - [*(Note that Request is unmaintained)*](https://github.com/request/request/issues/3142)
- [Axios](documentation/migration-guides/axios.md)
- [Node.js](documentation/migration-guides/nodejs.md)

## Got plugins

- [`got4aws`](https://github.com/SamVerschueren/got4aws) - Got convenience wrapper to interact with AWS v4 signed APIs
- [`gh-got`](https://github.com/sindresorhus/gh-got) - Got convenience wrapper to interact with the GitHub API
- [`gl-got`](https://github.com/singapore/gl-got) - Got convenience wrapper to interact with the GitLab API
- [`gotql`](https://github.com/khaosdoctor/gotql) - Got convenience wrapper to interact with GraphQL using JSON-parsed queries instead of strings
- [`got-fetch`](https://github.com/alexghr/got-fetch) - Got with a [`fetch`](https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API) interface
- [`got-scraping`](https://github.com/apify/got-scraping) - Got wrapper specifically designed for web scraping purposes
- [`got-ssrf`](https://github.com/JaneJeon/got-ssrf) - Got wrapper to protect server-side requests against SSRF attacks

## Comparison

|                       | `got`               | [`node-fetch`][n0]   | [`ky`][k0]               | [`axios`][a0]      | [`superagent`][s0]     |
|-----------------------|:-------------------:|:--------------------:|:------------------------:|:------------------:|:----------------------:|
| HTTP/2 support        | :heavy_check_mark:  | :x:                  | :heavy_check_mark:       | :x:                | :heavy_check_mark:\*\* |
| Browser support       | :x:                 | :heavy_check_mark:\* | :heavy_check_mark:       | :heavy_check_mark: | :heavy_check_mark:     |
| Promise API           | :heavy_check_mark:  | :heavy_check_mark:   | :heavy_check_mark:       | :heavy_check_mark: | :heavy_check_mark:     |
| Stream API            | :heavy_check_mark:  | Node.js only         | :x:                      | :x:                | :heavy_check_mark:     |
| Pagination API        | :heavy_check_mark:  | :x:                  | :x:                      | :x:                | :x:                    |
| Request aborting       | :heavy_check_mark:  | :heavy_check_mark:   | :heavy_check_mark:       | :heavy_check_mark: | :heavy_check_mark:     |
| RFC 7234 caching      | :heavy_check_mark:  | :x:                  | :x:                      | :x:                | :x:                    |
| Cookies (out-of-the-box) | :heavy_check_mark: | :x:                | :x:                      | :x:                | :x:                    |
| Follows redirects     | :heavy_check_mark:  | :heavy_check_mark:   | :heavy_check_mark:       | :heavy_check_mark: | :heavy_check_mark:     |
| Retries on failure    | :heavy_check_mark:  | :x:                  | :heavy_check_mark:       | :x:                | :heavy_check_mark:     |
| Progress events       | :heavy_check_mark:  | :x:                  | :heavy_check_mark: | Browser only       | :heavy_check_mark:     |
| Handles gzip/deflate  | :heavy_check_mark:  | :heavy_check_mark:   | :heavy_check_mark:       | :heavy_check_mark: | :heavy_check_mark:     |
| Advanced timeouts     | :heavy_check_mark:  | :x:                  | :x:                      | :x:                | :x:                    |
| Timings               | :heavy_check_mark:  | :x:                  | :x:                      | :x:                | :x:                    |
| Errors with metadata  | :heavy_check_mark:  | :x:                  | :heavy_check_mark:       | :heavy_check_mark: | :x:                    |
| JSON mode             | :heavy_check_mark:  | :heavy_check_mark:   | :heavy_check_mark:       | :heavy_check_mark: | :heavy_check_mark:     |
| Custom defaults       | :heavy_check_mark:  | :x:                  | :heavy_check_mark:       | :heavy_check_mark: | :x:                    |
| Composable            | :heavy_check_mark:  | :x:                  | :x:                      | :x:                | :heavy_check_mark:     |
| Hooks                 | :heavy_check_mark:  | :x:                  | :heavy_check_mark:       | :heavy_check_mark: | :x:                    |
| Issues open           | [![][gio]][g1]      | [![][nio]][n1]       | [![][kio]][k1]           | [![][aio]][a1]     | [![][sio]][s1]         |
| Issues closed         | [![][gic]][g2]      | [![][nic]][n2]       | [![][kic]][k2]           | [![][aic]][a2]     | [![][sic]][s2]         |
| Downloads             | [![][gd]][g3]       | [![][nd]][n3]        | [![][kd]][k3]            | [![][ad]][a3]      | [![][sd]][s3]          |
| Coverage              | TBD                 | [![][nc]][n4]        | [![][kc]][k4]            | [![][ac]][a4]      | [![][sc]][s4]          |
| Build                 | [![][gb]][g5]       | [![][nb]][n5]        | [![][kb]][k5]            | [![][ab]][a5]      | [![][sb]][s5]          |
| Bugs                  | [![][gbg]][g6]      | [![][nbg]][n6]       | [![][kbg]][k6]           | [![][abg]][a6]     | [![][sbg]][s6]         |
| Dependents            | [![][gdp]][g7]      | [![][ndp]][n7]       | [![][kdp]][k7]           | [![][adp]][a7]     | [![][sdp]][s7]         |
| Install size          | [![][gis]][g8]      | [![][nis]][n8]       | [![][kis]][k8]           | [![][ais]][a8]     | [![][sis]][s8]         |
| GitHub stars          | [![][gs]][g9]       | [![][ns]][n9]        | [![][ks]][k9]            | [![][as]][a9]      | [![][ss]][s9]          |
| TypeScript support    | [![][gts]][g10]     | [![][nts]][n10]      | [![][kts]][k10]          | [![][ats]][a10]    | [![][sts]][s11]        |
| Last commit           | [![][glc]][g11]     | [![][nlc]][n11]      | [![][klc]][k11]          | [![][alc]][a11]    | [![][slc]][s11]        |

\* It's almost API compatible with the browser `fetch` API.\
\*\* Need to switch the protocol manually. Doesn't accept PUSH streams and doesn't reuse HTTP/2 sessions.\
:sparkle: Almost-stable feature, but the API may change. Don't hesitate to try it out!\
:grey_question: Feature in early stage of development. Very experimental.

<!-- GITHUB -->
[k0]: https://github.com/sindresorhus/ky
[n0]: https://github.com/node-fetch/node-fetch
[a0]: https://github.com/axios/axios
[s0]: https://github.com/visionmedia/superagent

<!-- ISSUES OPEN -->
[gio]: https://img.shields.io/github/issues-raw/sindresorhus/got?color=gray&label
[kio]: https://img.shields.io/github/issues-raw/sindresorhus/ky?color=gray&label
[nio]: https://img.shields.io/github/issues-raw/bitinn/node-fetch?color=gray&label
[aio]: https://img.shields.io/github/issues-raw/axios/axios?color=gray&label
[sio]: https://img.shields.io/github/issues-raw/visionmedia/superagent?color=gray&label

[g1]: https://github.com/sindresorhus/got/issues?q=is%3Aissue+is%3Aopen+sort%3Aupdated-desc
[k1]: https://github.com/sindresorhus/ky/issues?q=is%3Aissue+is%3Aopen+sort%3Aupdated-desc
[n1]: https://github.com/bitinn/node-fetch/issues?q=is%3Aissue+is%3Aopen+sort%3Aupdated-desc
[a1]: https://github.com/axios/axios/issues?q=is%3Aissue+is%3Aopen+sort%3Aupdated-desc
[s1]: https://github.com/visionmedia/superagent/issues?q=is%3Aissue+is%3Aopen+sort%3Aupdated-desc

<!-- ISSUES CLOSED -->
[gic]: https://img.shields.io/github/issues-closed-raw/sindresorhus/got?color=blue&label
[kic]: https://img.shields.io/github/issues-closed-raw/sindresorhus/ky?color=blue&label
[nic]: https://img.shields.io/github/issues-closed-raw/bitinn/node-fetch?color=blue&label
[aic]: https://img.shields.io/github/issues-closed-raw/axios/axios?color=blue&label
[sic]: https://img.shields.io/github/issues-closed-raw/visionmedia/superagent?color=blue&label

[g2]: https://github.com/sindresorhus/got/issues?q=is%3Aissue+is%3Aclosed+sort%3Aupdated-desc
[k2]: https://github.com/sindresorhus/ky/issues?q=is%3Aissue+is%3Aclosed+sort%3Aupdated-desc
[n2]: https://github.com/bitinn/node-fetch/issues?q=is%3Aissue+is%3Aclosed+sort%3Aupdated-desc
[a2]: https://github.com/axios/axios/issues?q=is%3Aissue+is%3Aclosed+sort%3Aupdated-desc
[s2]: https://github.com/visionmedia/superagent/issues?q=is%3Aissue+is%3Aclosed+sort%3Aupdated-desc

<!-- DOWNLOADS -->
[gd]: https://img.shields.io/npm/dm/got?color=darkgreen&label
[kd]: https://img.shields.io/npm/dm/ky?color=darkgreen&label
[nd]: https://img.shields.io/npm/dm/node-fetch?color=darkgreen&label
[ad]: https://img.shields.io/npm/dm/axios?color=darkgreen&label
[sd]: https://img.shields.io/npm/dm/superagent?color=darkgreen&label

[g3]: https://www.npmjs.com/package/got
[k3]: https://www.npmjs.com/package/ky
[n3]: https://www.npmjs.com/package/node-fetch
[a3]: https://www.npmjs.com/package/axios
[s3]: https://www.npmjs.com/package/superagent

<!-- COVERAGE -->
[kc]: https://img.shields.io/codecov/c/github/sindresorhus/ky?color=0b9062&label
[nc]: https://img.shields.io/coveralls/github/bitinn/node-fetch?color=0b9062&label
[ac]: https://img.shields.io/coveralls/github/mzabriskie/axios?color=0b9062&label
[sc]: https://img.shields.io/codecov/c/github/visionmedia/superagent?color=0b9062&label

[k4]: https://codecov.io/gh/sindresorhus/ky
[n4]: https://coveralls.io/github/bitinn/node-fetch
[a4]: https://coveralls.io/github/mzabriskie/axios
[s4]: https://codecov.io/gh/visionmedia/superagent

<!-- BUILD -->
[gb]: https://github.com/sindresorhus/got/actions/workflows/main.yml/badge.svg
[kb]: https://github.com/sindresorhus/ky/actions/workflows/main.yml/badge.svg
[nb]: https://img.shields.io/travis/bitinn/node-fetch?label
[ab]: https://img.shields.io/travis/axios/axios?label
[sb]: https://img.shields.io/travis/visionmedia/superagent?label

[g5]: https://github.com/sindresorhus/got/actions/workflows/main.yml
[k5]: https://github.com/sindresorhus/ky/actions/workflows/main.yml
[n5]: https://travis-ci.org/github/bitinn/node-fetch
[a5]: https://travis-ci.org/github/axios/axios
[s5]: https://travis-ci.org/github/visionmedia/superagent

<!-- BUGS -->
[gbg]: https://img.shields.io/github/issues-raw/sindresorhus/got/bug?color=darkred&label
[kbg]: https://img.shields.io/github/issues-raw/sindresorhus/ky/bug?color=darkred&label
[nbg]: https://img.shields.io/github/issues-raw/bitinn/node-fetch/bug?color=darkred&label
[abg]: https://img.shields.io/github/issues-raw/axios/axios/bug-fix?color=darkred&label
[sbg]: https://img.shields.io/github/issues-raw/visionmedia/superagent/Bug?color=darkred&label

[g6]: https://github.com/sindresorhus/got/issues?q=is%3Aissue+is%3Aopen+sort%3Aupdated-desc+label%3Abug
[k6]: https://github.com/sindresorhus/ky/issues?q=is%3Aissue+is%3Aopen+sort%3Aupdated-desc+label%3Abug
[n6]: https://github.com/bitinn/node-fetch/issues?q=is%3Aissue+is%3Aopen+sort%3Aupdated-desc+label%3Abug
[a6]: https://github.com/axios/axios/issues?q=is%3Aissue+is%3Aopen+sort%3Aupdated-desc+label%3A%22bug-fix%22
[s6]: https://github.com/visionmedia/superagent/issues?q=is%3Aissue+is%3Aopen+sort%3Aupdated-desc+label%3ABug

<!-- DEPENDENTS -->
[gdp]: https://badgen.net/npm/dependents/got?color=orange&label
[kdp]: https://badgen.net/npm/dependents/ky?color=orange&label
[ndp]: https://badgen.net/npm/dependents/node-fetch?color=orange&label
[adp]: https://badgen.net/npm/dependents/axios?color=orange&label
[sdp]: https://badgen.net/npm/dependents/superagent?color=orange&label

[g7]: https://www.npmjs.com/package/got?activeTab=dependents
[k7]: https://www.npmjs.com/package/ky?activeTab=dependents
[n7]: https://www.npmjs.com/package/node-fetch?activeTab=dependents
[a7]: https://www.npmjs.com/package/axios?activeTab=dependents
[s7]: https://www.npmjs.com/package/visionmedia?activeTab=dependents

<!-- INSTALL SIZE -->
[gis]: https://packagephobia.com/badge?p=got
[kis]: https://packagephobia.com/badge?p=ky
[nis]: https://packagephobia.com/badge?p=node-fetch
[ais]: https://packagephobia.com/badge?p=axios
[sis]: https://packagephobia.com/badge?p=superagent

[g8]: https://packagephobia.com/result?p=got
[k8]: https://packagephobia.com/result?p=ky
[n8]: https://packagephobia.com/result?p=node-fetch
[a8]: https://packagephobia.com/result?p=axios
[s8]: https://packagephobia.com/result?p=superagent

<!-- GITHUB STARS -->
[gs]: https://img.shields.io/github/stars/sindresorhus/got?color=white&label
[ks]: https://img.shields.io/github/stars/sindresorhus/ky?color=white&label
[ns]: https://img.shields.io/github/stars/bitinn/node-fetch?color=white&label
[as]: https://img.shields.io/github/stars/axios/axios?color=white&label
[ss]: https://img.shields.io/github/stars/visionmedia/superagent?color=white&label

[g9]: https://github.com/sindresorhus/got
[k9]: https://github.com/sindresorhus/ky
[n9]: https://github.com/node-fetch/node-fetch
[a9]: https://github.com/axios/axios
[s9]: https://github.com/visionmedia/superagent

<!-- TYPESCRIPT SUPPORT -->
[gts]: https://badgen.net/npm/types/got?label
[kts]: https://badgen.net/npm/types/ky?label
[nts]: https://badgen.net/npm/types/node-fetch?label
[ats]: https://badgen.net/npm/types/axios?label
[sts]: https://badgen.net/npm/types/superagent?label

[g10]: https://github.com/sindresorhus/got
[k10]: https://github.com/sindresorhus/ky
[n10]: https://github.com/node-fetch/node-fetch
[a10]: https://github.com/axios/axios

<!-- LAST COMMIT -->
[glc]: https://img.shields.io/github/last-commit/sindresorhus/got?color=gray&label
[klc]: https://img.shields.io/github/last-commit/sindresorhus/ky?color=gray&label
[nlc]: https://img.shields.io/github/last-commit/bitinn/node-fetch?color=gray&label
[alc]: https://img.shields.io/github/last-commit/axios/axios?color=gray&label
[slc]: https://img.shields.io/github/last-commit/visionmedia/superagent?color=gray&label

[g11]: https://github.com/sindresorhus/got/commits
[k11]: https://github.com/sindresorhus/ky/commits
[n11]: https://github.com/node-fetch/node-fetch/commits
[a11]: https://github.com/axios/axios/commits
[s11]: https://github.com/visionmedia/superagent/commits

[Click here][InstallSizeOfTheDependencies] to see the install size of the Got dependencies.

[InstallSizeOfTheDependencies]: https://packagephobia.com/result?p=@sindresorhus/is@8.0.0,byte-counter@0.1.0,cacheable-request@13.0.18,chunk-data@0.1.0,decompress-response@10.0.0,keyv@5.6.0,lowercase-keys@4.0.1,responselike@4.0.2,type-fest@5.6.0,uint8array-extras@1.5.0

## Maintainers

[![Sindre Sorhus](https://github.com/sindresorhus.png?size=100)](https://sindresorhus.com) | [![Szymon Marczak](https://github.com/szmarczak.png?size=100)](https://github.com/szmarczak)
---|---
[Sindre Sorhus](https://sindresorhus.com) | [Szymon Marczak](https://github.com/szmarczak)

<a name="widely-used"></a>
## These amazing companies are using Got

<table>
<tbody>
	<tr>
		<td align="center">
			<a href="https://segment.com">
				<img width="90" valign="middle" src="https://user-images.githubusercontent.com/697676/47693700-ddb62500-dbb7-11e8-8332-716a91010c2d.png">
			</a>
		</td>
		<td align="center">
			<a href="https://antora.org">
				<img width="100" valign="middle" src="https://user-images.githubusercontent.com/79351/47706840-d874cc80-dbef-11e8-87c6-5f0c60cbf5dc.png">
			</a>
		</td>
		<td align="center">
			<a href="https://getvoip.com">
				<img width="150" valign="middle" src="https://user-images.githubusercontent.com/10832620/47869404-429e9480-dddd-11e8-8a7a-ca43d7f06020.png">
			</a>
		</td>
		<td align="center">
			<a href="https://github.com/exoframejs/exoframe">
				<img width="150" valign="middle" src="https://user-images.githubusercontent.com/365944/47791460-11a95b80-dd1a-11e8-9070-e8f2a215e03a.png">
			</a>
		</td>
	</tr>
	<tr>
		<td align="center">
			<a href="http://karaokes.moe">
				<img width="140" valign="middle" src="https://karaokes.moe/assets/images/index.png">
			</a>
		</td>
		<td align="center">
			<a href="https://github.com/renovatebot/renovate">
				<img width="150" valign="middle" src="https://avatars.githubusercontent.com/u/38656520?s=200&v=4">
			</a>
		</td>
		<td align="center">
			<a href="https://resist.bot">
				<img width="150" valign="middle" src="https://user-images.githubusercontent.com/3322287/51992724-28736180-2473-11e9-9764-599cfda4b012.png">
			</a>
		</td>
		<td align="center">
			<a href="https://www.naturalcycles.com">
				<img width="150" valign="middle" src="https://user-images.githubusercontent.com/170270/92244143-d0a8a200-eec2-11ea-9fc0-1c07f90b2113.png">
			</a>
		</td>
	</tr>
	<tr>
		<td align="center">
			<a href="https://microlink.io">
				<img width="150" valign="middle" src="https://user-images.githubusercontent.com/36894700/91992974-1cc5dc00-ed35-11ea-9d04-f58b42ce6a5e.png">
			</a>
		</td>
		<td align="center">
			<a href="https://radity.com">
				<img width="150" valign="middle" src="https://user-images.githubusercontent.com/29518613/91814036-97fb9500-ec44-11ea-8c6c-d198cc23ca29.png">
			</a>
		</td>
	</tr>
</tbody>
</table>

<!-- <br> -->

<!-- *Creating an awesome product? Open an issue to get listed here.* -->

<br>

> Segment is a happy user of Got! Got powers the main backend API that our app talks to. It's used by our in-house RPC client that we use to communicate with all microservices.
>
> — <a href="https://github.com/vadimdemedes">Vadim Demedes</a>

> Antora, a static site generator for creating documentation sites, uses Got to download the UI bundle. In Antora, the UI bundle (aka theme) is maintained as a separate project. That project exports the UI as a zip file we call the UI bundle. The main site generator downloads that UI from a URL using Got and streams it to vinyl-zip to extract the files. Those files go on to be used to create the HTML pages and supporting assets.
>
> — <a href="https://github.com/mojavelinux">Dan Allen</a>

> GetVoIP is happily using Got in production. One of the unique capabilities of Got is the ability to handle Unix sockets which enables us to build a full control interfaces for our docker stack.
>
> — <a href="https://github.com/danielkalen">Daniel Kalen</a>

> We're using Got inside of Exoframe to handle all the communication between CLI and server. Exoframe is a self-hosted tool that allows simple one-command deployments using Docker.
>
> — <a href="https://github.com/yamalight">Tim Ermilov</a>

> Karaoke Mugen uses Got to fetch content updates from its online server.
>
> — <a href="https://github.com/AxelTerizaki">Axel Terizaki</a>

> Renovate uses Got, gh-got and gl-got to send millions of queries per day to GitHub, GitLab, npmjs, PyPi, Packagist, Docker Hub, Terraform, CircleCI, and more.
>
> — <a href="https://github.com/rarkins">Rhys Arkins</a>

> Resistbot uses Got to communicate from the API frontend where all correspondence ingresses to the officials lookup database in back.
>
> — <a href="https://github.com/chris-erickson">Chris Erickson</a>

> Natural Cycles is using Got to communicate with all kinds of 3rd-party REST APIs (over 9000!).
>
> — <a href="https://github.com/kirillgroshkov">Kirill Groshkov</a>

> Microlink is a cloud browser as an API service that uses Got widely as the main HTTP client, serving ~22M requests a month, every time a network call needs to be performed.
>
> — <a href="https://github.com/Kikobeats">Kiko Beats</a>

> We’re using Got at Radity. Thanks for such an amazing work!
>
> — <a href="https://github.com/MirzayevFarid">Mirzayev Farid</a>

[> Back to homepage](../readme.md#documentation)

## Let's make a plugin!

> Another example on how to use Got like a boss :electric_plug:

Okay, so you already have learned some basics. That's great!

When it comes to advanced usage, custom instances are really helpful.
For example, take a look at [`gh-got`](https://github.com/sindresorhus/gh-got).
It looks pretty complicated, but... it's simple and extremely useful.

Before we start, we need to find the [GitHub API docs](https://developer.github.com/v3/).

Let's write down the most important information:
1. The root endpoint is `https://api.github.com/`.
2. We will use version 3 of the API.\
   The `Accept` header needs to be set to `application/vnd.github.v3+json`.
3. The body is in a JSON format.
4. We will use OAuth2 for authorization.
5. We may receive `400 Bad Request` or `422 Unprocessable Entity`.\
   The body contains detailed information about the error.
6. *Pagination?* Yeah! Supported natively by Got.
7. Rate limiting. These headers are interesting:

- `X-RateLimit-Limit`
- `X-RateLimit-Remaining`
- `X-RateLimit-Reset`

Also `X-GitHub-Request-Id` may be useful for debugging.

8. The `User-Agent` header is required.

When we have all the necessary info, we can start mixing :cake:

### The root endpoint

Not much to do here. Just extend an instance and provide the `prefixUrl` option:

```js
import got from 'got';

const instance = got.extend({
	prefixUrl: 'https://api.github.com'
});

export default instance;
```

### v3 API

GitHub needs to know which API version we are using. We'll use the `Accept` header for that:

```js
import got from 'got';

const instance = got.extend({
	prefixUrl: 'https://api.github.com',
	headers: {
		accept: 'application/vnd.github.v3+json'
	}
});

export default instance;
```

### JSON body

We'll use [`options.responseType`](2-options.md#responsetype):

```js
import got from 'got';

const instance = got.extend({
	prefixUrl: 'https://api.github.com',
	headers: {
		accept: 'application/vnd.github.v3+json'
	},
	responseType: 'json'
});

export default instance;
```

### Authorization

It's common to set some environment variables, for example, `GITHUB_TOKEN`. You can modify the tokens in all your apps easily, right? Cool. What about... we want to provide a unique token for each app. Then we will need to create a new option - it will default to the environment variable, but you can easily override it.

Got performs option validation and doesn't know that `token` is a wanted option so it will throw. We can handle it inside an `init` hook and save it in `options.context`.

```js
import got from 'got';

const instance = got.extend({
	prefixUrl: 'https://api.github.com',
	headers: {
		accept: 'application/vnd.github.v3+json'
	},
	responseType: 'json',
	context: {
		token: process.env.GITHUB_TOKEN,
	},
	hooks: {
		init: [
			(raw, options) => {
				if ('token' in raw) {
					options.context.token = raw.token;
					delete raw.token;
				}
			}
		]
	}
});

export default instance;
```

For the rest we will use a handler. We could use hooks, but this way it will be more readable. Having `beforeRequest`, `beforeError` and `afterResponse` hooks for just a few lines of code would complicate things unnecessarily.

**Tip:**
> - It's a good practice to use hooks when your plugin gets complicated.
> - Try not to overload the handler function, but don't abuse hooks either.

```js
import got from 'got';

const instance = got.extend({
	prefixUrl: 'https://api.github.com',
	headers: {
		accept: 'application/vnd.github.v3+json'
	},
	responseType: 'json',
	context: {
		token: process.env.GITHUB_TOKEN,
	},
	hooks: {
		init: [
			(raw, options) => {
				if ('token' in raw) {
					options.context.token = raw.token;
					delete raw.token;
				}
			}
		]
	},
	handlers: [
		(options, next) => {
			// Authorization
			const {token} = options.context;
			if (token && !options.headers.authorization) {
				options.headers.authorization = `token ${token}`;
			}

			return next(options);
		}
	]
});

export default instance;
```

### Errors

We should name our errors, just to know if the error is from the API response. Superb errors, here we come!

```js
...
	handlers: [
		(options, next) => {
			// Authorization
			const {token} = options.context;
			if (token && !options.headers.authorization) {
				options.headers.authorization = `token ${token}`;
			}

			// Don't touch streams
			if (options.isStream) {
				return next(options);
			}

			// Magic begins
			return (async () => {
				try {
					const response = await next(options);

					return response;
				} catch (error) {
					const {response} = error;

					// Nicer errors
					if (response && response.body) {
						error.name = 'GitHubError';
						error.message = `${response.body.message} (${response.statusCode} status code)`;
					}

					throw error;
				}
			})();
		}
	]
...
```

Note that by providing our own errors in handlers, we don't alter the ones in `beforeError` hooks.\
The conversion is the last thing here.

### Rate limiting

Umm... `response.headers['x-ratelimit-remaining']` doesn't look good. What about `response.rateLimit.limit` instead?\
Yeah, definitely. Since `response.headers` is an object, we can easily parse these:

```js
const getRateLimit = (headers) => ({
	limit: Number.parseInt(headers['x-ratelimit-limit'], 10),
	remaining: Number.parseInt(headers['x-ratelimit-remaining'], 10),
	reset: new Date(Number.parseInt(headers['x-ratelimit-reset'], 10) * 1000)
});

getRateLimit({
	'x-ratelimit-limit': '60',
	'x-ratelimit-remaining': '55',
	'x-ratelimit-reset': '1562852139'
});
// => {
// 	limit: 60,
// 	remaining: 55,
// 	reset: 2019-07-11T13:35:39.000Z
// }
```

Let's integrate it:

```js
const getRateLimit = (headers) => ({
	limit: Number.parseInt(headers['x-ratelimit-limit'], 10),
	remaining: Number.parseInt(headers['x-ratelimit-remaining'], 10),
	reset: new Date(Number.parseInt(headers['x-ratelimit-reset'], 10) * 1000)
});

...
	handlers: [
		(options, next) => {
			// Authorization
			const {token} = options.context;
			if (token && !options.headers.authorization) {
				options.headers.authorization = `token ${token}`;
			}

			// Don't touch streams
			if (options.isStream) {
				return next(options);
			}

			// Magic begins
			return (async () => {
				try {
					const response = await next(options);

					// Rate limit for the Response object
					response.rateLimit = getRateLimit(response.headers);

					return response;
				} catch (error) {
					const {response} = error;

					// Nicer errors
					if (response && response.body) {
						error.name = 'GitHubError';
						error.message = `${response.body.message} (${response.statusCode} status code)`;
					}

					// Rate limit for errors
					if (response) {
						error.rateLimit = getRateLimit(response.headers);
					}

					throw error;
				}
			})();
		}
	]
...
```

### The frosting on the cake: `User-Agent` header.

```js
const packageJson = {
	name: 'gh-got',
	version: '12.0.0'
};

const instance = got.extend({
	...
	headers: {
		accept: 'application/vnd.github.v3+json',
		'user-agent': `${packageJson.name}/${packageJson.version}`
	},
	...
});
```

## Woah. Is that it?

Yup. View the full source code [here](examples/gh-got.js). Here's an example of how to use it:

```js
import ghGot from 'gh-got';

const response = await ghGot('users/sindresorhus');
const creationDate = new Date(response.created_at);

console.log(`Sindre's GitHub profile was created on ${creationDate.toGMTString()}`);
// => Sindre's GitHub profile was created on Sun, 20 Dec 2009 22:57:02 GMT
```

### Pagination

```js
import ghGot from 'gh-got';

const countLimit = 50;
const pagination = ghGot.paginate(
	'repos/sindresorhus/got/commits',
	{
		pagination: {countLimit}
	}
);

console.log(`Printing latest ${countLimit} Got commits (newest to oldest):`);

for await (const commitData of pagination) {
	console.log(commitData.commit.message);
}
```

That's... astonishing! We don't have to implement pagination on our own. Got handles it all.

### At the end

Did you know you can mix many instances into a bigger, more powerful one? Check out the [Advanced Creation](examples/advanced-creation.js) guide.

'use strict';

const _ = require('lodash');
const async = require('async');
const path = require('path');

const file = require('../common/file');
const util = require('../common/util');

const basePath = path.join(__dirname, '..', '..');
const distPath = path.join(basePath, 'dist');

const filePairs = [
  [path.join(distPath, 'lodash.core.js'), 'core.js'],
  [path.join(distPath, 'lodash.core.min.js'), 'core.min.js'],
  [path.join(distPath, 'lodash.min.js'), 'lodash.min.js']
];

/*----------------------------------------------------------------------------*/

/**
 * Creates supplementary Lodash modules at the `target` path.
 *
 * @private
 * @param {string} target The output directory path.
 */
function build(target) {
  const actions = _.map(filePairs, pair =>
    file.copy(pair[0], path.join(target, pair[1])));

  async.series(actions, util.pitch);
}

build(_.last(process.argv));

{
  "version": 2,
  "metadata": {
    "name": "benchmark-template",
    "catch2-version": "3.15.2"
  },
  "listings": {
    "tests": [
      {
        "name": "Comparing function pointers",
        "tags": [
          "function pointer",
          "Tricky"
        ]
      },
      {
        "name": "Testing checked-if 4",
        "tags": [
          "!shouldfail",
          "checked-if"
        ]
      },
      {
        "name": "count_equidistant_floats - double",
        "tags": [
          "approvals",
          "distance",
          "floating-point"
        ]
      },
      {
        "name": "Usage of AllTrue range matcher",
        "tags": [
          "matchers",
          "quantifiers",
          "templated"
        ]
      },
      {
        "name": "Exception matchers that succeed",
        "tags": [
          "!throws",
          "exceptions",
          "matchers"
        ]
      },
      {
        "name": "A TEMPLATE_TEST_CASE_METHOD based test run that succeeds - float",
        "class-name": "Template_Fixture",
        "tags": [
          "class",
          "template"
        ]
      },
      {
        "name": "Approximate PI",
        "tags": [
          "Approx",
          "PI"
        ]
      },
      {
        "name": "TextFlow::Column respects width setting",
        "tags": [
          "approvals",
          "column",
          "TextFlow"
        ]
      },
      {
        "name": "Generators internals",
        "tags": [
          "generators",
          "internals"
        ]
      },
      {
        "name": "Mayfail test case with nested sections",
        "tags": [
          "!mayfail"
        ]
      }
    ]
  }
}

name: Publish
on:
  push:
    tags: ['*']
jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
      - uses: astral-sh/setup-uv@f0ec1fc3b38f5e7cd731bb6ce540c5af426746bb # v6.1.0
        with:
          enable-cache: true
          prune-cache: false
      - uses: actions/setup-python@a26af69be951a213d495a4c3e4e4022e16d87065 # v5.6.0
        with:
          python-version-file: pyproject.toml
      - run: echo "SOURCE_DATE_EPOCH=$(git log -1 --pretty=%ct)" >> $GITHUB_ENV
      - run: uv build
      - uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
        with:
          path: ./dist
  create-release:
    needs: [build]
    runs-on: ubuntu-latest
    permissions:
      contents: write
    steps:
      - uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093 # v4.3.0
      - name: create release
        run: >
          gh release create --draft --repo ${{ github.repository }}
          ${{ github.ref_name }} artifact/*
        env:
          GH_TOKEN: ${{ github.token }}
  publish-pypi:
    needs: [build]
    environment:
      name: publish
      url: https://pypi.org/project/Jinja2/${{ github.ref_name }}
    runs-on: ubuntu-latest
    permissions:
      id-token: write
    steps:
      - uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093 # v4.3.0
      - uses: pypa/gh-action-pypi-publish@76f52bc884231f62b9a034ebfe128415bbaabdfc # v1.12.4
        with:
          packages-dir: artifact/

[> Back to homepage](../readme.md#documentation)

## Errors

Source code:
- [`source/core/errors.ts`](../source/core/errors.ts)
- [`source/as-promise/types.ts`](../source/as-promise/types.ts)
- [`source/core/response.ts`](../source/core/response.ts)

All Got errors contain various metadata, such as:

- `code` - A string like `ERR_NON_2XX_3XX_RESPONSE`,
- `options` - An instance of [`Options`](2-options.md),
- `request` - An instance of Got Stream,
- `response` (optional) - An instance of Got Response,
- `timings` (optional) - Points to `response.timings`.

#### Capturing async stack traces

Read the article [here](async-stack-traces.md).

> [!NOTE]
> - The error codes may differ when the root error has a `code` property set.
> - The root error will be propagated as is via the [`cause`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error/cause) property.

### `RequestError`

**Code: `ERR_GOT_REQUEST_ERROR`**

When a request fails. Contains a `code` property with error class code, like `ECONNREFUSED`. All the errors below inherit this one.

### `CacheError`

**Code: `ERR_CACHE_ACCESS`**

When a cache method fails, for example, if the database goes down or there's a filesystem error.

### `ReadError`

**Code: `ERR_READING_RESPONSE_STREAM` or `ERR_HTTP_CONTENT_LENGTH_MISMATCH`**

When reading from response stream fails.

The error code will be `ERR_HTTP_CONTENT_LENGTH_MISMATCH` when the `strictContentLength` option is enabled and the server specifies a `content-length` header but the actual number of bytes received doesn't match.

### `ParseError`

**Code: `ERR_BODY_PARSE_FAILURE`**

When server response code is 2xx, and parsing body fails. Includes a `response` property.

### `UploadError`

**Code: `ERR_UPLOAD`**

When the request body is a stream and an error occurs while reading from that stream.

### `HTTPError`

**Code: `ERR_NON_2XX_3XX_RESPONSE`**

When the request is unsuccessful.

A request is successful when the status code of the final request is `2xx` or `3xx`.

When [following redirects](2-options.md#followredirect), a request is successful **only** when the status code of the final request is `2xx`.

> [!NOTE]
> `304` responses are always considered successful.

### `MaxRedirectsError`

**Code: `ERR_TOO_MANY_REDIRECTS`**

When the server redirects you more than ten times. Includes a `response` property.

### `UnsupportedProtocolError`

> [!NOTE]
> This error is not public.

**Code: `ERR_UNSUPPORTED_PROTOCOL`**

When given an unsupported protocol.

### `TimeoutError`

**Code: `ETIMEDOUT`**

When the request is aborted due to a [timeout](6-timeout.md). Includes an `event` (a string) property along with `timings`.

### `RetryError`

**Code: `ERR_RETRYING`**

Always triggers a new retry when thrown.

### `AbortError`

**Code: `ERR_ABORTED`**

When the request is aborted with [AbortController.abort()](https://developer.mozilla.org/en-US/docs/Web/API/AbortController/abort).

'use strict'

var users = require('./db');

exports.html = function(req, res){
  res.send('<ul>' + users.map(function(user){
    return '<li>' + user.name + '</li>';
  }).join('') + '</ul>');
};

exports.text = function(req, res){
  res.send(users.map(function(user){
    return ' - ' + user.name + '\n';
  }).join(''));
};

exports.json = function(req, res){
  res.json(users);
};

from typing_extensions import assert_type

import click


@click.command()
@click.help_option("-h", "--help")
def hello() -> None:
    """Simple program that greets NAME for a total of COUNT times."""
    click.echo("Hello!")


assert_type(hello, click.Command)

# Frequently Asked Questions

```{contents}
:depth: 2
:local: true
```

## General

### Shell Variable Expansion On Windows

I have a simple Click app :

```
import click

@click.command()
@click.argument('message')
def main(message: str):
    click.echo(message)

if __name__ == '__main__':
    main()

```

When you pass an environment variable in the argument, it expands it:

```{code-block} powershell
> Desktop python foo.py '$M0/.viola/2025-01-25-17-20-23-307878'
> M:/home/ramrachum/.viola/2025-01-25-17-20-23-307878
>
```
Note that I used single quotes above, so my shell is not expanding the environment variable, Click does. How do I get Click to not expand it?

#### Answer

If you don't want Click to emulate (as best it can) unix expansion on Windows, pass windows_expand_args=False when calling the CLI.
Windows command line doesn't do any *, ~, or $ENV expansion. It also doesn't distinguish between double quotes and single quotes (where the later means "don't expand here"). Click emulates the expansion so that the app behaves similarly on both platforms, but doesn't receive information about what quotes were used.

<a id="top"></a>
# List of examples

## Already available

- Test Case: [Single-file](../examples/010-TestCase.cpp)
- Test Case: [Multiple-file 1](../examples/020-TestCase-1.cpp), [2](../examples/020-TestCase-2.cpp)
- Assertion: [REQUIRE, CHECK](../examples/030-Asn-Require-Check.cpp)
- Fixture: [Sections](../examples/100-Fix-Section.cpp)
- Fixture: [Class-based fixtures](../examples/110-Fix-ClassFixture.cpp)
- Fixture: [Persistent fixtures](../examples/111-Fix-PersistentFixture.cpp)
- BDD: [SCENARIO, GIVEN, WHEN, THEN](../examples/120-Bdd-ScenarioGivenWhenThen.cpp)
- Listener: [Listeners](../examples/210-Evt-EventListeners.cpp)
- Configuration: [Provide your own output streams](../examples/231-Cfg-OutputStreams.cpp)
- Generators: [Create your own generator](../examples/300-Gen-OwnGenerator.cpp)
- Generators: [Use map to convert types in GENERATE expression](../examples/301-Gen-MapTypeConversion.cpp)
- Generators: [Run test with a table of input values](../examples/302-Gen-Table.cpp)
- Generators: [Use variables in generator expressions](../examples/310-Gen-VariablesInGenerators.cpp)
- Generators: [Use custom variable capture in generator expressions](../examples/311-Gen-CustomCapture.cpp)


## Planned

- Assertion: [REQUIRE_THAT and Matchers](../examples/040-Asn-RequireThat.cpp)
- Assertion: [REQUIRE_NO_THROW](../examples/050-Asn-RequireNoThrow.cpp)
- Assertion: [REQUIRE_THROWS](../examples/050-Asn-RequireThrows.cpp)
- Assertion: [REQUIRE_THROWS_AS](../examples/070-Asn-RequireThrowsAs.cpp)
- Assertion: [REQUIRE_THROWS_WITH](../examples/080-Asn-RequireThrowsWith.cpp)
- Assertion: [REQUIRE_THROWS_MATCHES](../examples/090-Asn-RequireThrowsMatches.cpp)
- Floating point: [Approx - Comparisons](../examples/130-Fpt-Approx.cpp)
- Logging: [CAPTURE - Capture expression](../examples/140-Log-Capture.cpp)
- Logging: [INFO - Provide information with failure](../examples/150-Log-Info.cpp)
- Logging: [WARN - Issue warning](../examples/160-Log-Warn.cpp)
- Logging: [FAIL, FAIL_CHECK - Issue message and force failure/continue](../examples/170-Log-Fail.cpp)
- Logging: [SUCCEED - Issue message and continue](../examples/180-Log-Succeed.cpp)
- Report: [User-defined type](../examples/190-Rpt-ReportUserDefinedType.cpp)
- Report: [User-defined reporter](../examples/202-Rpt-UserDefinedReporter.cpp)
- Report: [Automake reporter](../examples/205-Rpt-AutomakeReporter.cpp)
- Report: [TAP reporter](../examples/206-Rpt-TapReporter.cpp)
- Report: [Multiple reporter](../examples/208-Rpt-MultipleReporters.cpp)
- Configuration: [Provide your own main()](../examples/220-Cfg-OwnMain.cpp)
- Configuration: [Compile-time configuration](../examples/230-Cfg-CompileTimeConfiguration.cpp)
- Configuration: [Run-time configuration](../examples/240-Cfg-RunTimeConfiguration.cpp)

---

[Home](Readme.md#top)

import importlib.metadata

import pytest

import click
import click.core
import click.parser
import click.shell_completion
import click.utils


@pytest.mark.parametrize(
    ("module", "name", "target"),
    [
        # Stream helpers, re-exported from both `click` and `click.utils`.
        (click, "get_binary_stream", click.utils._get_binary_stream),
        (click, "get_text_stream", click.utils._get_text_stream),
        (click.utils, "get_binary_stream", click.utils._get_binary_stream),
        (click.utils, "get_text_stream", click.utils._get_text_stream),
        # Command-class aliases, re-exported from `click` and `click.core`.
        (click, "BaseCommand", click.core._BaseCommand),
        (click, "MultiCommand", click.core._MultiCommand),
        (click.core, "BaseCommand", click.core._BaseCommand),
        (click.core, "MultiCommand", click.core._MultiCommand),
        # Old parser API (moved to `optparse`); `OptionParser` is also
        # re-exported from the top-level `click` namespace.
        (click, "OptionParser", click.parser._OptionParser),
        (click.parser, "OptionParser", click.parser._OptionParser),
        (click.parser, "Argument", click.parser._Argument),
        (click.parser, "Option", click.parser._Option),
        (click.parser, "split_opt", click.parser._split_opt),
        (click.parser, "normalize_opt", click.parser._normalize_opt),
        (click.parser, "ParsingState", click.parser._ParsingState),
        (click.parser, "split_arg_string", click.shell_completion.split_arg_string),
        # Deprecated `click.utils` utilities.
        (click.utils, "LazyFile", click.utils._LazyFile),
        (click.utils, "KeepOpenFile", click.utils._KeepOpenFile),
        (click.utils, "make_default_short_help", click.utils._make_default_short_help),
        (click.utils, "PacifyFlushWrapper", click.utils._PacifyFlushWrapper),
        (click.utils, "safecall", click.utils._safecall),
        # Version metadata attribute.
        (click, "__version__", importlib.metadata.version("click")),
    ],
    ids=lambda v: getattr(v, "__name__", v),
)
def test_attr_deprecated(module, name, target):
    with pytest.warns(DeprecationWarning, match=name):
        value = getattr(module, name)

    assert value == target


@pytest.mark.parametrize(
    "module",
    [click, click.core, click.parser, click.utils],
    ids=lambda m: m.__name__,
)
def test_unknown_attribute_raises(module):
    with pytest.raises(AttributeError, match="no_such_attribute"):
        _ = module.no_such_attribute


def test_context_protected_args_deprecated():
    ctx = click.Context(click.Command("cli"))

    with pytest.warns(DeprecationWarning, match="protected_args"):
        assert ctx.protected_args == []


def test_isolated_filesystem_deprecated(runner):
    with pytest.warns(DeprecationWarning, match="isolated_filesystem"):
        with runner.isolated_filesystem():
            pass

'use strict'

var express = require('../')
  , request = require('supertest');

describe('app', function(){
  describe('.param(names, fn)', function(){
    it('should map the array', function(done){
      var app = express();

      app.param(['id', 'uid'], function(req, res, next, id){
        id = Number(id);
        if (isNaN(id)) return next('route');
        req.params.id = id;
        next();
      });

      app.get('/post/:id', function(req, res){
        var id = req.params.id;
        res.send((typeof id) + ':' + id)
      });

      app.get('/user/:uid', function(req, res){
        var id = req.params.id;
        res.send((typeof id) + ':' + id)
      });

      request(app)
        .get('/user/123')
        .expect(200, 'number:123', function (err) {
          if (err) return done(err)
          request(app)
            .get('/post/123')
            .expect('number:123', done)
        })
    })
  })

  describe('.param(name, fn)', function(){
    it('should map logic for a single param', function(done){
      var app = express();

      app.param('id', function(req, res, next, id){
        id = Number(id);
        if (isNaN(id)) return next('route');
        req.params.id = id;
        next();
      });

      app.get('/user/:id', function(req, res){
        var id = req.params.id;
        res.send((typeof id) + ':' + id)
      });

      request(app)
        .get('/user/123')
        .expect(200, 'number:123', done)
    })

    it('should only call once per request', function(done) {
      var app = express();
      var called = 0;
      var count = 0;

      app.param('user', function(req, res, next, user) {
        called++;
        req.user = user;
        next();
      });

      app.get('/foo/:user', function(req, res, next) {
        count++;
        next();
      });
      app.get('/foo/:user', function(req, res, next) {
        count++;
        next();
      });
      app.use(function(req, res) {
        res.end([count, called, req.user].join(' '));
      });

      request(app)
      .get('/foo/bob')
      .expect('2 1 bob', done);
    })

    it('should call when values differ', function(done) {
      var app = express();
      var called = 0;
      var count = 0;

      app.param('user', function(req, res, next, user) {
        called++;
        req.users = (req.users || []).concat(user);
        next();
      });

      app.get('/:user/bob', function(req, res, next) {
        count++;
        next();
      });
      app.get('/foo/:user', function(req, res, next) {
        count++;
        next();
      });
      app.use(function(req, res) {
        res.end([count, called, req.users.join(',')].join(' '));
      });

      request(app)
      .get('/foo/bob')
      .expect('2 2 foo,bob', done);
    })

    it('should support altering req.params across routes', function(done) {
      var app = express();

      app.param('user', function(req, res, next, user) {
        req.params.user = 'loki';
        next();
      });

      app.get('/:user', function(req, res, next) {
        next('route');
      });
      app.get('/:user', function (req, res) {
        res.send(req.params.user);
      });

      request(app)
      .get('/bob')
      .expect('loki', done);
    })

    it('should not invoke without route handler', function(done) {
      var app = express();

      app.param('thing', function(req, res, next, thing) {
        req.thing = thing;
        next();
      });

      app.param('user', function(req, res, next, user) {
        next(new Error('invalid invocation'))
      });

      app.post('/:user', function (req, res) {
        res.send(req.params.user);
      });

      app.get('/:thing', function (req, res) {
        res.send(req.thing);
      });

      request(app)
      .get('/bob')
      .expect(200, 'bob', done);
    })

    it('should work with encoded values', function(done){
      var app = express();

      app.param('name', function(req, res, next, name){
        req.params.name = name;
        next();
      });

      app.get('/user/:name', function(req, res){
        var name = req.params.name;
        res.send('' + name);
      });

      request(app)
      .get('/user/foo%25bar')
      .expect('foo%bar', done);
    })

    it('should catch thrown error', function(done){
      var app = express();

      app.param('id', function(req, res, next, id){
        throw new Error('err!');
      });

      app.get('/user/:id', function(req, res){
        var id = req.params.id;
        res.send('' + id);
      });

      request(app)
      .get('/user/123')
      .expect(500, done);
    })

    it('should catch thrown secondary error', function(done){
      var app = express();

      app.param('id', function(req, res, next, val){
        process.nextTick(next);
      });

      app.param('id', function(req, res, next, id){
        throw new Error('err!');
      });

      app.get('/user/:id', function(req, res){
        var id = req.params.id;
        res.send('' + id);
      });

      request(app)
      .get('/user/123')
      .expect(500, done);
    })

    it('should defer to next route', function(done){
      var app = express();

      app.param('id', function(req, res, next, id){
        next('route');
      });

      app.get('/user/:id', function(req, res){
        var id = req.params.id;
        res.send('' + id);
      });

      app.get('/:name/123', function(req, res){
        res.send('name');
      });

      request(app)
      .get('/user/123')
      .expect('name', done);
    })

    it('should defer all the param routes', function(done){
      var app = express();

      app.param('id', function(req, res, next, val){
        if (val === 'new') return next('route');
        return next();
      });

      app.all('/user/:id', function(req, res){
        res.send('all.id');
      });

      app.get('/user/:id', function(req, res){
        res.send('get.id');
      });

      app.get('/user/new', function(req, res){
        res.send('get.new');
      });

      request(app)
      .get('/user/new')
      .expect('get.new', done);
    })

    it('should not call when values differ on error', function(done) {
      var app = express();
      var called = 0;
      var count = 0;

      app.param('user', function(req, res, next, user) {
        called++;
        if (user === 'foo') throw new Error('err!');
        req.user = user;
        next();
      });

      app.get('/:user/bob', function(req, res, next) {
        count++;
        next();
      });
      app.get('/foo/:user', function(req, res, next) {
        count++;
        next();
      });

      app.use(function(err, req, res, next) {
        res.status(500);
        res.send([count, called, err.message].join(' '));
      });

      request(app)
      .get('/foo/bob')
      .expect(500, '0 1 err!', done)
    });

    it('should call when values differ when using "next"', function(done) {
      var app = express();
      var called = 0;
      var count = 0;

      app.param('user', function(req, res, next, user) {
        called++;
        if (user === 'foo') return next('route');
        req.user = user;
        next();
      });

      app.get('/:user/bob', function(req, res, next) {
        count++;
        next();
      });
      app.get('/foo/:user', function(req, res, next) {
        count++;
        next();
      });
      app.use(function(req, res) {
        res.end([count, called, req.user].join(' '));
      });

      request(app)
      .get('/foo/bob')
      .expect('1 2 bob', done);
    })
  })
})

[project]
name = "click-example-termui"
version = "1.0.0"
description = "Click termui example"
requires-python = ">=3.10"
dependencies = [
    "click>=8.1",
]

[project.scripts]
termui = "termui:cli"

[build-system]
requires = ["flit_core<4"]
build-backend = "flit_core.buildapi"

[tool.flit.module]
name = "termui"

'use strict';

const _ = require('lodash');

/*----------------------------------------------------------------------------*/

/**
 * Creates a hash object. If a `properties` object is provided, its own
 * enumerable properties are assigned to the created hash.
 *
 * @memberOf util
 * @param {Object} [properties] The properties to assign to the hash.
 * @returns {Object} Returns the new hash object.
 */
function Hash(properties) {
  return _.transform(properties, (result, value, key) => {
    result[key] = (_.isPlainObject(value) && !(value instanceof Hash))
      ? new Hash(value)
      : value;
  }, this);
}

Hash.prototype = Object.create(null);

/**
 * This method throws any error it receives.
 *
 * @memberOf util
 * @param {Object} [error] The error object.
 */
function pitch(error) {
  if (error != null) {
    throw error;
  }
}

module.exports = {
  Hash,
  pitch
};

'use strict'

var express = require('../../..');

var apiv2 = express.Router();

apiv2.get('/', function(req, res) {
  res.send('Hello from APIv2 root route.');
});

apiv2.get('/users', function(req, res) {
  res.send('List of APIv2 users.');
});

module.exports = apiv2;

/*!
 * express
 * Copyright(c) 2009-2013 TJ Holowaychuk
 * Copyright(c) 2013 Roman Shtylman
 * Copyright(c) 2014-2015 Douglas Christopher Wilson
 * MIT Licensed
 */

'use strict';

/**
 * Module dependencies.
 * @private
 */

var finalhandler = require('finalhandler');
var debug = require('debug')('express:application');
var View = require('./view');
var http = require('node:http');
var methods = require('./utils').methods;
var compileETag = require('./utils').compileETag;
var compileQueryParser = require('./utils').compileQueryParser;
var compileTrust = require('./utils').compileTrust;
var resolve = require('node:path').resolve;
var once = require('once')
var Router = require('router');

/**
 * Module variables.
 * @private
 */

var slice = Array.prototype.slice;
var flatten = Array.prototype.flat;

/**
 * Application prototype.
 */

var app = exports = module.exports = {};

/**
 * Variable for trust proxy inheritance back-compat
 * @private
 */

var trustProxyDefaultSymbol = '@@symbol:trust_proxy_default';

/**
 * Initialize the server.
 *
 *   - setup default configuration
 *   - setup default middleware
 *   - setup route reflection methods
 *
 * @private
 */

app.init = function init() {
  var router = null;

  this.cache = Object.create(null);
  this.engines = Object.create(null);
  this.settings = Object.create(null);

  this.defaultConfiguration();

  // Setup getting to lazily add base router
  Object.defineProperty(this, 'router', {
    configurable: true,
    enumerable: true,
    get: function getrouter() {
      if (router === null) {
        router = new Router({
          caseSensitive: this.enabled('case sensitive routing'),
          strict: this.enabled('strict routing')
        });
      }

      return router;
    }
  });
};

/**
 * Initialize application configuration.
 * @private
 */

app.defaultConfiguration = function defaultConfiguration() {
  var env = process.env.NODE_ENV || 'development';

  // default settings
  this.enable('x-powered-by');
  this.set('etag', 'weak');
  this.set('env', env);
  this.set('query parser', 'simple')
  this.set('subdomain offset', 2);
  this.set('trust proxy', false);

  // trust proxy inherit back-compat
  Object.defineProperty(this.settings, trustProxyDefaultSymbol, {
    configurable: true,
    value: true
  });

  debug('booting in %s mode', env);

  this.on('mount', function onmount(parent) {
    // inherit trust proxy
    if (this.settings[trustProxyDefaultSymbol] === true
      && typeof parent.settings['trust proxy fn'] === 'function') {
      delete this.settings['trust proxy'];
      delete this.settings['trust proxy fn'];
    }

    // inherit protos
    Object.setPrototypeOf(this.request, parent.request)
    Object.setPrototypeOf(this.response, parent.response)
    Object.setPrototypeOf(this.engines, parent.engines)
    Object.setPrototypeOf(this.settings, parent.settings)
  });

  // setup locals
  this.locals = Object.create(null);

  // top-most app is mounted at /
  this.mountpath = '/';

  // default locals
  this.locals.settings = this.settings;

  // default configuration
  this.set('view', View);
  this.set('views', resolve('views'));
  this.set('jsonp callback name', 'callback');

  if (env === 'production') {
    this.enable('view cache');
  }
};

/**
 * Dispatch a req, res pair into the application. Starts pipeline processing.
 *
 * If no callback is provided, then default error handlers will respond
 * in the event of an error bubbling through the stack.
 *
 * @private
 */

app.handle = function handle(req, res, callback) {
  // final handler
  var done = callback || finalhandler(req, res, {
    env: this.get('env'),
    onerror: logerror.bind(this)
  });

  // set powered by header
  if (this.enabled('x-powered-by')) {
    res.setHeader('X-Powered-By', 'Express');
  }

  // set circular references
  req.res = res;
  res.req = req;

  // alter the prototypes
  Object.setPrototypeOf(req, this.request)
  Object.setPrototypeOf(res, this.response)

  // setup locals
  if (!res.locals) {
    res.locals = Object.create(null);
  }

  this.router.handle(req, res, done);
};

/**
 * Proxy `Router#use()` to add middleware to the app router.
 * See Router#use() documentation for details.
 *
 * If the _fn_ parameter is an express app, then it will be
 * mounted at the _route_ specified.
 *
 * @public
 */

app.use = function use(fn) {
  var offset = 0;
  var path = '/';

  // default path to '/'
  // disambiguate app.use([fn])
  if (typeof fn !== 'function') {
    var arg = fn;

    while (Array.isArray(arg) && arg.length !== 0) {
      arg = arg[0];
    }

    // first arg is the path
    if (typeof arg !== 'function') {
      offset = 1;
      path = fn;
    }
  }

  var fns = flatten.call(slice.call(arguments, offset), Infinity);

  if (fns.length === 0) {
    throw new TypeError('app.use() requires a middleware function')
  }

  // get router
  var router = this.router;

  fns.forEach(function (fn) {
    // non-express app
    if (!fn || !fn.handle || !fn.set) {
      return router.use(path, fn);
    }

    debug('.use app under %s', path);
    fn.mountpath = path;
    fn.parent = this;

    // restore .app property on req and res
    router.use(path, function mounted_app(req, res, next) {
      var orig = req.app;
      fn.handle(req, res, function (err) {
        Object.setPrototypeOf(req, orig.request)
        Object.setPrototypeOf(res, orig.response)
        next(err);
      });
    });

    // mounted an app
    fn.emit('mount', this);
  }, this);

  return this;
};

/**
 * Proxy to the app `Router#route()`
 * Returns a new `Route` instance for the _path_.
 *
 * Routes are isolated middleware stacks for specific paths.
 * See the Route api docs for details.
 *
 * @public
 */

app.route = function route(path) {
  return this.router.route(path);
};

/**
 * Register the given template engine callback `fn`
 * as `ext`.
 *
 * By default will `require()` the engine based on the
 * file extension. For example if you try to render
 * a "foo.ejs" file Express will invoke the following internally:
 *
 *     app.engine('ejs', require('ejs').__express);
 *
 * For engines that do not provide `.__express` out of the box,
 * or if you wish to "map" a different extension to the template engine
 * you may use this method. For example mapping the EJS template engine to
 * ".html" files:
 *
 *     app.engine('html', require('ejs').renderFile);
 *
 * In this case EJS provides a `.renderFile()` method with
 * the same signature that Express expects: `(path, options, callback)`,
 * though note that it aliases this method as `ejs.__express` internally
 * so if you're using ".ejs" extensions you don't need to do anything.
 *
 * Some template engines do not follow this convention, the
 * [Consolidate.js](https://github.com/tj/consolidate.js)
 * library was created to map all of node's popular template
 * engines to follow this convention, thus allowing them to
 * work seamlessly within Express.
 *
 * @param {String} ext
 * @param {Function} fn
 * @return {app} for chaining
 * @public
 */

app.engine = function engine(ext, fn) {
  if (typeof fn !== 'function') {
    throw new Error('callback function required');
  }

  // get file extension
  var extension = ext[0] !== '.'
    ? '.' + ext
    : ext;

  // store engine
  this.engines[extension] = fn;

  return this;
};

/**
 * Proxy to `Router#param()` with one added api feature. The _name_ parameter
 * can be an array of names.
 *
 * See the Router#param() docs for more details.
 *
 * @param {String|Array} name
 * @param {Function} fn
 * @return {app} for chaining
 * @public
 */

app.param = function param(name, fn) {
  if (Array.isArray(name)) {
    for (var i = 0; i < name.length; i++) {
      this.param(name[i], fn);
    }

    return this;
  }

  this.router.param(name, fn);

  return this;
};

/**
 * Assign `setting` to `val`, or return `setting`'s value.
 *
 *    app.set('foo', 'bar');
 *    app.set('foo');
 *    // => "bar"
 *
 * Mounted servers inherit their parent server's settings.
 *
 * @param {String} setting
 * @param {*} [val]
 * @return {Server} for chaining
 * @public
 */

app.set = function set(setting, val) {
  if (arguments.length === 1) {
    // app.get(setting)
    return this.settings[setting];
  }

  debug('set "%s" to %o', setting, val);

  // set value
  this.settings[setting] = val;

  // trigger matched settings
  switch (setting) {
    case 'etag':
      this.set('etag fn', compileETag(val));
      break;
    case 'query parser':
      this.set('query parser fn', compileQueryParser(val));
      break;
    case 'trust proxy':
      this.set('trust proxy fn', compileTrust(val));

      // trust proxy inherit back-compat
      Object.defineProperty(this.settings, trustProxyDefaultSymbol, {
        configurable: true,
        value: false
      });

      break;
  }

  return this;
};

/**
 * Return the app's absolute pathname
 * based on the parent(s) that have
 * mounted it.
 *
 * For example if the application was
 * mounted as "/admin", which itself
 * was mounted as "/blog" then the
 * return value would be "/blog/admin".
 *
 * @return {String}
 * @private
 */

app.path = function path() {
  return this.parent
    ? this.parent.path() + this.mountpath
    : '';
};

/**
 * Check if `setting` is enabled (truthy).
 *
 *    app.enabled('foo')
 *    // => false
 *
 *    app.enable('foo')
 *    app.enabled('foo')
 *    // => true
 *
 * @param {String} setting
 * @return {Boolean}
 * @public
 */

app.enabled = function enabled(setting) {
  return Boolean(this.set(setting));
};

/**
 * Check if `setting` is disabled.
 *
 *    app.disabled('foo')
 *    // => true
 *
 *    app.enable('foo')
 *    app.disabled('foo')
 *    // => false
 *
 * @param {String} setting
 * @return {Boolean}
 * @public
 */

app.disabled = function disabled(setting) {
  return !this.set(setting);
};

/**
 * Enable `setting`.
 *
 * @param {String} setting
 * @return {app} for chaining
 * @public
 */

app.enable = function enable(setting) {
  return this.set(setting, true);
};

/**
 * Disable `setting`.
 *
 * @param {String} setting
 * @return {app} for chaining
 * @public
 */

app.disable = function disable(setting) {
  return this.set(setting, false);
};

/**
 * Delegate `.VERB(...)` calls to `router.VERB(...)`.
 */

methods.forEach(function (method) {
  app[method] = function (path) {
    if (method === 'get' && arguments.length === 1) {
      // app.get(setting)
      return this.set(path);
    }

    var route = this.route(path);
    route[method].apply(route, slice.call(arguments, 1));
    return this;
  };
});

/**
 * Special-cased "all" method, applying the given route `path`,
 * middleware, and callback to _every_ HTTP method.
 *
 * @param {String} path
 * @param {Function} ...
 * @return {app} for chaining
 * @public
 */

app.all = function all(path) {
  var route = this.route(path);
  var args = slice.call(arguments, 1);

  for (var i = 0; i < methods.length; i++) {
    route[methods[i]].apply(route, args);
  }

  return this;
};

/**
 * Render the given view `name` name with `options`
 * and a callback accepting an error and the
 * rendered template string.
 *
 * Example:
 *
 *    app.render('email', { name: 'Tobi' }, function(err, html){
 *      // ...
 *    })
 *
 * @param {String} name
 * @param {Object|Function} options or fn
 * @param {Function} callback
 * @public
 */

app.render = function render(name, options, callback) {
  var cache = this.cache;
  var done = callback;
  var engines = this.engines;
  var opts = options || {};
  var view;

  // support callback function as second arg
  if (typeof options === 'function') {
    done = options;
    opts = {};
  }

  // merge options
  var renderOptions = { ...this.locals, ...opts._locals, ...opts };

  // set .cache unless explicitly provided
  if (renderOptions.cache == null) {
    renderOptions.cache = this.enabled('view cache');
  }

  // primed cache
  if (renderOptions.cache) {
    view = cache[name];
  }

  // view
  if (!view) {
    var View = this.get('view');

    view = new View(name, {
      defaultEngine: this.get('view engine'),
      root: this.get('views'),
      engines: engines
    });

    if (!view.path) {
      var dirs = Array.isArray(view.root) && view.root.length > 1
        ? 'directories "' + view.root.slice(0, -1).join('", "') + '" or "' + view.root[view.root.length - 1] + '"'
        : 'directory "' + view.root + '"'
      var err = new Error('Failed to lookup view "' + name + '" in views ' + dirs);
      err.view = view;
      return done(err);
    }

    // prime the cache
    if (renderOptions.cache) {
      cache[name] = view;
    }
  }

  // render
  tryRender(view, renderOptions, done);
};

/**
 * Listen for connections.
 *
 * A node `http.Server` is returned, with this
 * application (which is a `Function`) as its
 * callback. If you wish to create both an HTTP
 * and HTTPS server you may do so with the "http"
 * and "https" modules as shown here:
 *
 *    var http = require('node:http')
 *      , https = require('node:https')
 *      , express = require('express')
 *      , app = express();
 *
 *    http.createServer(app).listen(80);
 *    https.createServer({ ... }, app).listen(443);
 *
 * @return {http.Server}
 * @public
 */

app.listen = function listen() {
  var server = http.createServer(this)
  var args = slice.call(arguments)
  if (typeof args[args.length - 1] === 'function') {
    var done = args[args.length - 1] = once(args[args.length - 1])
    server.once('error', done)
  }
  return server.listen.apply(server, args)
}

/**
 * Log error using console.error.
 *
 * @param {Error} err
 * @private
 */

function logerror(err) {
  /* istanbul ignore next */
  if (this.get('env') !== 'test') console.error(err);
}

/**
 * Try rendering a view.
 * @private
 */

function tryRender(view, options, callback) {
  try {
    view.render(options, callback);
  } catch (err) {
    callback(err);
  }
}

version: 2
updates:
  - package-ecosystem: github-actions
    directory: /
    schedule:
      interval: monthly

  - package-ecosystem: npm
    directory: /
    schedule:
      interval: monthly
      time: "23:00"
      timezone: Europe/London
    open-pull-requests-limit: 10
    ignore:
      - dependency-name: "*"
        update-types: ["version-update:semver-major"]

<a id="top"></a>
# Reference

To get the most out of Catch2, start with the [tutorial](tutorial.md#top).
Once you're up and running consider the following reference material.

**Writing tests:**
* [Assertion macros](assertions.md#top)
* [Matchers (asserting complex properties)](matchers.md#top)
* [Comparing floating point numbers](comparing-floating-point-numbers.md#top)
* [Logging macros](logging.md#top)
* [Test cases and sections](test-cases-and-sections.md#top)
* [Test fixtures](test-fixtures.md#top)
* [Explicitly skipping, passing, and failing tests at runtime](skipping-passing-failing.md#top)
* [Reporters (output customization)](reporters.md#top)
* [Event Listeners](event-listeners.md#top)
* [Data Generators (value parameterized tests)](generators.md#top)
* [Other macros](other-macros.md#top)
* [Micro benchmarking](benchmarks.md#top)

**Fine tuning:**
* [Supplying your own main()](own-main.md#top)
* [Compile-time configuration](configuration.md#top)
* [String Conversions](tostring.md#top)

**Running:**
* [Command line reference](command-line.md#top)
* [Running specific section/generator](filtering-execution-path.md#top)

**Odds and ends:**
* [Frequently Asked Questions (FAQ)](faq.md#top)
* [Best practices and other tips](usage-tips.md#top)
* [CMake integration](cmake-integration.md#top)
* [Tooling integration (CI, test runners, other)](ci-and-misc.md#top)
* [Known limitations](limitations.md#top)
* [Thread safety in Catch2](thread-safety.md#top)

**Other:**
* [Why Catch2?](why-catch.md#top)
* [Migrating from v2 to v3](migrate-v2-to-v3.md#top)
* [Open Source Projects using Catch2](opensource-users.md#top)
* [Commercial Projects using Catch2](commercial-users.md#top)
* [Contributing](contributing.md#top)
* [Release Notes](release-notes.md#top)
* [Deprecations and incoming changes](deprecations.md#top)

import type {Writable, Readable} from 'node:stream';
import type {ClientRequest} from 'node:http';

function isClientRequest(clientRequest: Writable | Readable): clientRequest is ClientRequest {
	return (clientRequest as Writable).writable && !(clientRequest as Writable).writableEnded;
}

export default isClientRequest;

import pytest

from jinja2 import DictLoader
from jinja2 import Environment
from jinja2 import TemplateRuntimeError
from jinja2 import TemplateSyntaxError
from jinja2 import UndefinedError


@pytest.fixture
def env_trim():
    return Environment(trim_blocks=True)


class TestForLoop:
    def test_simple(self, env):
        tmpl = env.from_string("{% for item in seq %}{{ item }}{% endfor %}")
        assert tmpl.render(seq=list(range(10))) == "0123456789"

    def test_else(self, env):
        tmpl = env.from_string("{% for item in seq %}XXX{% else %}...{% endfor %}")
        assert tmpl.render() == "..."

    def test_else_scoping_item(self, env):
        tmpl = env.from_string("{% for item in [] %}{% else %}{{ item }}{% endfor %}")
        assert tmpl.render(item=42) == "42"

    def test_empty_blocks(self, env):
        tmpl = env.from_string("<{% for item in seq %}{% else %}{% endfor %}>")
        assert tmpl.render() == "<>"

    def test_context_vars(self, env):
        slist = [42, 24]
        for seq in [slist, iter(slist), reversed(slist), (_ for _ in slist)]:
            tmpl = env.from_string(
                """{% for item in seq -%}
            {{ loop.index }}|{{ loop.index0 }}|{{ loop.revindex }}|{{
                loop.revindex0 }}|{{ loop.first }}|{{ loop.last }}|{{
               loop.length }}###{% endfor %}"""
            )
            one, two, _ = tmpl.render(seq=seq).split("###")
            (
                one_index,
                one_index0,
                one_revindex,
                one_revindex0,
                one_first,
                one_last,
                one_length,
            ) = one.split("|")
            (
                two_index,
                two_index0,
                two_revindex,
                two_revindex0,
                two_first,
                two_last,
                two_length,
            ) = two.split("|")

            assert int(one_index) == 1 and int(two_index) == 2
            assert int(one_index0) == 0 and int(two_index0) == 1
            assert int(one_revindex) == 2 and int(two_revindex) == 1
            assert int(one_revindex0) == 1 and int(two_revindex0) == 0
            assert one_first == "True" and two_first == "False"
            assert one_last == "False" and two_last == "True"
            assert one_length == two_length == "2"

    def test_cycling(self, env):
        tmpl = env.from_string(
            """{% for item in seq %}{{
            loop.cycle('<1>', '<2>') }}{% endfor %}{%
            for item in seq %}{{ loop.cycle(*through) }}{% endfor %}"""
        )
        output = tmpl.render(seq=list(range(4)), through=("<1>", "<2>"))
        assert output == "<1><2>" * 4

    def test_lookaround(self, env):
        tmpl = env.from_string(
            """{% for item in seq -%}
            {{ loop.previtem|default('x') }}-{{ item }}-{{
            loop.nextitem|default('x') }}|
        {%- endfor %}"""
        )
        output = tmpl.render(seq=list(range(4)))
        assert output == "x-0-1|0-1-2|1-2-3|2-3-x|"

    def test_changed(self, env):
        tmpl = env.from_string(
            """{% for item in seq -%}
            {{ loop.changed(item) }},
        {%- endfor %}"""
        )
        output = tmpl.render(seq=[None, None, 1, 2, 2, 3, 4, 4, 4])
        assert output == "True,False,True,True,False,True,True,False,False,"

    def test_scope(self, env):
        tmpl = env.from_string("{% for item in seq %}{% endfor %}{{ item }}")
        output = tmpl.render(seq=list(range(10)))
        assert not output

    def test_varlen(self, env):
        tmpl = env.from_string("{% for item in iter %}{{ item }}{% endfor %}")
        output = tmpl.render(iter=range(5))
        assert output == "01234"

    def test_noniter(self, env):
        tmpl = env.from_string("{% for item in none %}...{% endfor %}")
        pytest.raises(TypeError, tmpl.render)

    def test_recursive(self, env):
        tmpl = env.from_string(
            """{% for item in seq recursive -%}
            [{{ item.a }}{% if item.b %}<{{ loop(item.b) }}>{% endif %}]
        {%- endfor %}"""
        )
        assert (
            tmpl.render(
                seq=[
                    dict(a=1, b=[dict(a=1), dict(a=2)]),
                    dict(a=2, b=[dict(a=1), dict(a=2)]),
                    dict(a=3, b=[dict(a="a")]),
                ]
            )
            == "[1<[1][2]>][2<[1][2]>][3<[a]>]"
        )

    def test_recursive_lookaround(self, env):
        tmpl = env.from_string(
            """{% for item in seq recursive -%}
            [{{ loop.previtem.a if loop.previtem is defined else 'x' }}.{{
            item.a }}.{{ loop.nextitem.a if loop.nextitem is defined else 'x'
            }}{% if item.b %}<{{ loop(item.b) }}>{% endif %}]
        {%- endfor %}"""
        )
        assert (
            tmpl.render(
                seq=[
                    dict(a=1, b=[dict(a=1), dict(a=2)]),
                    dict(a=2, b=[dict(a=1), dict(a=2)]),
                    dict(a=3, b=[dict(a="a")]),
                ]
            )
            == "[x.1.2<[x.1.2][1.2.x]>][1.2.3<[x.1.2][1.2.x]>][2.3.x<[x.a.x]>]"
        )

    def test_recursive_depth0(self, env):
        tmpl = env.from_string(
            """{% for item in seq recursive -%}
        [{{ loop.depth0 }}:{{ item.a }}{% if item.b %}<{{ loop(item.b) }}>{% endif %}]
        {%- endfor %}"""
        )
        assert (
            tmpl.render(
                seq=[
                    dict(a=1, b=[dict(a=1), dict(a=2)]),
                    dict(a=2, b=[dict(a=1), dict(a=2)]),
                    dict(a=3, b=[dict(a="a")]),
                ]
            )
            == "[0:1<[1:1][1:2]>][0:2<[1:1][1:2]>][0:3<[1:a]>]"
        )

    def test_recursive_depth(self, env):
        tmpl = env.from_string(
            """{% for item in seq recursive -%}
        [{{ loop.depth }}:{{ item.a }}{% if item.b %}<{{ loop(item.b) }}>{% endif %}]
        {%- endfor %}"""
        )
        assert (
            tmpl.render(
                seq=[
                    dict(a=1, b=[dict(a=1), dict(a=2)]),
                    dict(a=2, b=[dict(a=1), dict(a=2)]),
                    dict(a=3, b=[dict(a="a")]),
                ]
            )
            == "[1:1<[2:1][2:2]>][1:2<[2:1][2:2]>][1:3<[2:a]>]"
        )

    def test_looploop(self, env):
        tmpl = env.from_string(
            """{% for row in table %}
            {%- set rowloop = loop -%}
            {% for cell in row -%}
                [{{ rowloop.index }}|{{ loop.index }}]
            {%- endfor %}
        {%- endfor %}"""
        )
        assert tmpl.render(table=["ab", "cd"]) == "[1|1][1|2][2|1][2|2]"

    def test_reversed_bug(self, env):
        tmpl = env.from_string(
            "{% for i in items %}{{ i }}{% if not loop.last %},{% endif %}{% endfor %}"
        )
        assert tmpl.render(items=reversed([3, 2, 1])) == "1,2,3"

    def test_loop_errors(self, env):
        tmpl = env.from_string(
            """{% for item in [1] if loop.index
                                      == 0 %}...{% endfor %}"""
        )
        pytest.raises(UndefinedError, tmpl.render)
        tmpl = env.from_string(
            """{% for item in [] %}...{% else
            %}{{ loop }}{% endfor %}"""
        )
        assert tmpl.render() == ""

    def test_loop_filter(self, env):
        tmpl = env.from_string(
            "{% for item in range(10) if item is even %}[{{ item }}]{% endfor %}"
        )
        assert tmpl.render() == "[0][2][4][6][8]"
        tmpl = env.from_string(
            """
            {%- for item in range(10) if item is even %}[{{
                loop.index }}:{{ item }}]{% endfor %}"""
        )
        assert tmpl.render() == "[1:0][2:2][3:4][4:6][5:8]"

    def test_loop_unassignable(self, env):
        pytest.raises(
            TemplateSyntaxError, env.from_string, "{% for loop in seq %}...{% endfor %}"
        )

    def test_scoped_special_var(self, env):
        t = env.from_string(
            "{% for s in seq %}[{{ loop.first }}{% for c in s %}"
            "|{{ loop.first }}{% endfor %}]{% endfor %}"
        )
        assert t.render(seq=("ab", "cd")) == "[True|True|False][False|True|False]"

    def test_scoped_loop_var(self, env):
        t = env.from_string(
            "{% for x in seq %}{{ loop.first }}"
            "{% for y in seq %}{% endfor %}{% endfor %}"
        )
        assert t.render(seq="ab") == "TrueFalse"
        t = env.from_string(
            "{% for x in seq %}{% for y in seq %}"
            "{{ loop.first }}{% endfor %}{% endfor %}"
        )
        assert t.render(seq="ab") == "TrueFalseTrueFalse"

    def test_recursive_empty_loop_iter(self, env):
        t = env.from_string(
            """
        {%- for item in foo recursive -%}{%- endfor -%}
        """
        )
        assert t.render(dict(foo=[])) == ""

    def test_call_in_loop(self, env):
        t = env.from_string(
            """
        {%- macro do_something() -%}
            [{{ caller() }}]
        {%- endmacro %}

        {%- for i in [1, 2, 3] %}
            {%- call do_something() -%}
                {{ i }}
            {%- endcall %}
        {%- endfor -%}
        """
        )
        assert t.render() == "[1][2][3]"

    def test_scoping_bug(self, env):
        t = env.from_string(
            """
        {%- for item in foo %}...{{ item }}...{% endfor %}
        {%- macro item(a) %}...{{ a }}...{% endmacro %}
        {{- item(2) -}}
        """
        )
        assert t.render(foo=(1,)) == "...1......2..."

    def test_unpacking(self, env):
        tmpl = env.from_string(
            "{% for a, b, c in [[1, 2, 3]] %}{{ a }}|{{ b }}|{{ c }}{% endfor %}"
        )
        assert tmpl.render() == "1|2|3"

    def test_intended_scoping_with_set(self, env):
        tmpl = env.from_string(
            "{% for item in seq %}{{ x }}{% set x = item %}{{ x }}{% endfor %}"
        )
        assert tmpl.render(x=0, seq=[1, 2, 3]) == "010203"

        tmpl = env.from_string(
            "{% set x = 9 %}{% for item in seq %}{{ x }}"
            "{% set x = item %}{{ x }}{% endfor %}"
        )
        assert tmpl.render(x=0, seq=[1, 2, 3]) == "919293"


class TestIfCondition:
    def test_simple(self, env):
        tmpl = env.from_string("""{% if true %}...{% endif %}""")
        assert tmpl.render() == "..."

    def test_elif(self, env):
        tmpl = env.from_string(
            """{% if false %}XXX{% elif true
            %}...{% else %}XXX{% endif %}"""
        )
        assert tmpl.render() == "..."

    def test_elif_deep(self, env):
        elifs = "\n".join(f"{{% elif a == {i} %}}{i}" for i in range(1, 1000))
        tmpl = env.from_string(f"{{% if a == 0 %}}0{elifs}{{% else %}}x{{% endif %}}")
        for x in (0, 10, 999):
            assert tmpl.render(a=x).strip() == str(x)
        assert tmpl.render(a=1000).strip() == "x"

    def test_else(self, env):
        tmpl = env.from_string("{% if false %}XXX{% else %}...{% endif %}")
        assert tmpl.render() == "..."

    def test_empty(self, env):
        tmpl = env.from_string("[{% if true %}{% else %}{% endif %}]")
        assert tmpl.render() == "[]"

    def test_complete(self, env):
        tmpl = env.from_string(
            "{% if a %}A{% elif b %}B{% elif c == d %}C{% else %}D{% endif %}"
        )
        assert tmpl.render(a=0, b=False, c=42, d=42.0) == "C"

    def test_no_scope(self, env):
        tmpl = env.from_string("{% if a %}{% set foo = 1 %}{% endif %}{{ foo }}")
        assert tmpl.render(a=True) == "1"
        tmpl = env.from_string("{% if true %}{% set foo = 1 %}{% endif %}{{ foo }}")
        assert tmpl.render() == "1"


class TestMacros:
    def test_simple(self, env_trim):
        tmpl = env_trim.from_string(
            """\
{% macro say_hello(name) %}Hello {{ name }}!{% endmacro %}
{{ say_hello('Peter') }}"""
        )
        assert tmpl.render() == "Hello Peter!"

    def test_scoping(self, env_trim):
        tmpl = env_trim.from_string(
            """\
{% macro level1(data1) %}
{% macro level2(data2) %}{{ data1 }}|{{ data2 }}{% endmacro %}
{{ level2('bar') }}{% endmacro %}
{{ level1('foo') }}"""
        )
        assert tmpl.render() == "foo|bar"

    def test_arguments(self, env_trim):
        tmpl = env_trim.from_string(
            """\
{% macro m(a, b, c='c', d='d') %}{{ a }}|{{ b }}|{{ c }}|{{ d }}{% endmacro %}
{{ m() }}|{{ m('a') }}|{{ m('a', 'b') }}|{{ m(1, 2, 3) }}"""
        )
        assert tmpl.render() == "||c|d|a||c|d|a|b|c|d|1|2|3|d"

    def test_arguments_defaults_nonsense(self, env_trim):
        pytest.raises(
            TemplateSyntaxError,
            env_trim.from_string,
            """\
{% macro m(a, b=1, c) %}a={{ a }}, b={{ b }}, c={{ c }}{% endmacro %}""",
        )

    def test_caller_defaults_nonsense(self, env_trim):
        pytest.raises(
            TemplateSyntaxError,
            env_trim.from_string,
            """\
{% macro a() %}{{ caller() }}{% endmacro %}
{% call(x, y=1, z) a() %}{% endcall %}""",
        )

    def test_varargs(self, env_trim):
        tmpl = env_trim.from_string(
            """\
{% macro test() %}{{ varargs|join('|') }}{% endmacro %}\
{{ test(1, 2, 3) }}"""
        )
        assert tmpl.render() == "1|2|3"

    def test_simple_call(self, env_trim):
        tmpl = env_trim.from_string(
            """\
{% macro test() %}[[{{ caller() }}]]{% endmacro %}\
{% call test() %}data{% endcall %}"""
        )
        assert tmpl.render() == "[[data]]"

    def test_complex_call(self, env_trim):
        tmpl = env_trim.from_string(
            """\
{% macro test() %}[[{{ caller('data') }}]]{% endmacro %}\
{% call(data) test() %}{{ data }}{% endcall %}"""
        )
        assert tmpl.render() == "[[data]]"

    def test_caller_undefined(self, env_trim):
        tmpl = env_trim.from_string(
            """\
{% set caller = 42 %}\
{% macro test() %}{{ caller is not defined }}{% endmacro %}\
{{ test() }}"""
        )
        assert tmpl.render() == "True"

    def test_include(self, env_trim):
        env_trim = Environment(
            loader=DictLoader(
                {"include": "{% macro test(foo) %}[{{ foo }}]{% endmacro %}"}
            )
        )
        tmpl = env_trim.from_string('{% from "include" import test %}{{ test("foo") }}')
        assert tmpl.render() == "[foo]"

    def test_macro_api(self, env_trim):
        tmpl = env_trim.from_string(
            "{% macro foo(a, b) %}{% endmacro %}"
            "{% macro bar() %}{{ varargs }}{{ kwargs }}{% endmacro %}"
            "{% macro baz() %}{{ caller() }}{% endmacro %}"
        )
        assert tmpl.module.foo.arguments == ("a", "b")
        assert tmpl.module.foo.name == "foo"
        assert not tmpl.module.foo.caller
        assert not tmpl.module.foo.catch_kwargs
        assert not tmpl.module.foo.catch_varargs
        assert tmpl.module.bar.arguments == ()
        assert not tmpl.module.bar.caller
        assert tmpl.module.bar.catch_kwargs
        assert tmpl.module.bar.catch_varargs
        assert tmpl.module.baz.caller

    def test_callself(self, env_trim):
        tmpl = env_trim.from_string(
            "{% macro foo(x) %}{{ x }}{% if x > 1 %}|"
            "{{ foo(x - 1) }}{% endif %}{% endmacro %}"
            "{{ foo(5) }}"
        )
        assert tmpl.render() == "5|4|3|2|1"

    def test_macro_defaults_self_ref(self, env):
        tmpl = env.from_string(
            """
            {%- set x = 42 %}
            {%- macro m(a, b=x, x=23) %}{{ a }}|{{ b }}|{{ x }}{% endmacro -%}
        """
        )
        assert tmpl.module.m(1) == "1||23"
        assert tmpl.module.m(1, 2) == "1|2|23"
        assert tmpl.module.m(1, 2, 3) == "1|2|3"
        assert tmpl.module.m(1, x=7) == "1|7|7"


class TestSet:
    def test_normal(self, env_trim):
        tmpl = env_trim.from_string("{% set foo = 1 %}{{ foo }}")
        assert tmpl.render() == "1"
        assert tmpl.module.foo == 1

    def test_block(self, env_trim):
        tmpl = env_trim.from_string("{% set foo %}42{% endset %}{{ foo }}")
        assert tmpl.render() == "42"
        assert tmpl.module.foo == "42"

    def test_block_escaping(self):
        env = Environment(autoescape=True)
        tmpl = env.from_string(
            "{% set foo %}<em>{{ test }}</em>{% endset %}foo: {{ foo }}"
        )
        assert tmpl.render(test="<unsafe>") == "foo: <em>&lt;unsafe&gt;</em>"

    def test_set_invalid(self, env_trim):
        pytest.raises(
            TemplateSyntaxError, env_trim.from_string, "{% set foo['bar'] = 1 %}"
        )
        tmpl = env_trim.from_string("{% set foo.bar = 1 %}")
        exc_info = pytest.raises(TemplateRuntimeError, tmpl.render, foo={})
        assert "non-namespace object" in exc_info.value.message

    def test_namespace_redefined(self, env_trim):
        tmpl = env_trim.from_string("{% set ns = namespace() %}{% set ns.bar = 'hi' %}")
        exc_info = pytest.raises(TemplateRuntimeError, tmpl.render, namespace=dict)
        assert "non-namespace object" in exc_info.value.message

    def test_namespace(self, env_trim):
        tmpl = env_trim.from_string(
            "{% set ns = namespace() %}{% set ns.bar = '42' %}{{ ns.bar }}"
        )
        assert tmpl.render() == "42"

    def test_namespace_block(self, env_trim):
        tmpl = env_trim.from_string(
            "{% set ns = namespace() %}{% set ns.bar %}42{% endset %}{{ ns.bar }}"
        )
        assert tmpl.render() == "42"

    def test_init_namespace(self, env_trim):
        tmpl = env_trim.from_string(
            "{% set ns = namespace(d, self=37) %}"
            "{% set ns.b = 42 %}"
            "{{ ns.a }}|{{ ns.self }}|{{ ns.b }}"
        )
        assert tmpl.render(d={"a": 13}) == "13|37|42"

    def test_namespace_loop(self, env_trim):
        tmpl = env_trim.from_string(
            "{% set ns = namespace(found=false) %}"
            "{% for x in range(4) %}"
            "{% if x == v %}"
            "{% set ns.found = true %}"
            "{% endif %}"
            "{% endfor %}"
            "{{ ns.found }}"
        )
        assert tmpl.render(v=3) == "True"
        assert tmpl.render(v=4) == "False"

    def test_namespace_macro(self, env_trim):
        tmpl = env_trim.from_string(
            "{% set ns = namespace() %}"
            "{% set ns.a = 13 %}"
            "{% macro magic(x) %}"
            "{% set x.b = 37 %}"
            "{% endmacro %}"
            "{{ magic(ns) }}"
            "{{ ns.a }}|{{ ns.b }}"
        )
        assert tmpl.render() == "13|37"

    def test_namespace_set_tuple(self, env_trim):
        tmpl = env_trim.from_string(
            "{% set ns = namespace(a=12, b=36) %}"
            "{% set ns.a, ns.b = ns.a + 1, ns.b + 1 %}"
            "{{ ns.a }}|{{ ns.b }}"
        )
        assert tmpl.render() == "13|37"

    def test_block_escaping_filtered(self):
        env = Environment(autoescape=True)
        tmpl = env.from_string(
            "{% set foo | trim %}<em>{{ test }}</em>    {% endset %}foo: {{ foo }}"
        )
        assert tmpl.render(test="<unsafe>") == "foo: <em>&lt;unsafe&gt;</em>"

    def test_block_filtered(self, env_trim):
        tmpl = env_trim.from_string(
            "{% set foo | trim | length | string %} 42    {% endset %}{{ foo }}"
        )
        assert tmpl.render() == "2"
        assert tmpl.module.foo == "2"

    def test_block_filtered_set(self, env_trim):
        def _myfilter(val, arg):
            assert arg == " xxx "
            return val

        env_trim.filters["myfilter"] = _myfilter
        tmpl = env_trim.from_string(
            '{% set a = " xxx " %}'
            "{% set foo | myfilter(a) | trim | length | string %}"
            ' {% set b = " yy " %} 42 {{ a }}{{ b }}   '
            "{% endset %}"
            "{{ foo }}"
        )
        assert tmpl.render() == "11"
        assert tmpl.module.foo == "11"


class TestWith:
    def test_with(self, env):
        tmpl = env.from_string(
            """\
        {% with a=42, b=23 -%}
            {{ a }} = {{ b }}
        {% endwith -%}
            {{ a }} = {{ b }}\
        """
        )
        assert [x.strip() for x in tmpl.render(a=1, b=2).splitlines()] == [
            "42 = 23",
            "1 = 2",
        ]

    def test_with_argument_scoping(self, env):
        tmpl = env.from_string(
            """\
        {%- with a=1, b=2, c=b, d=e, e=5 -%}
            {{ a }}|{{ b }}|{{ c }}|{{ d }}|{{ e }}
        {%- endwith -%}
        """
        )
        assert tmpl.render(b=3, e=4) == "1|2|3|4|5"

'use strict'

var assert = require('node:assert')
var AsyncLocalStorage = require('node:async_hooks').AsyncLocalStorage
const { Buffer } = require('node:buffer');

var express = require('..')
var request = require('supertest')

describe('express.urlencoded()', function () {
  before(function () {
    this.app = createApp()
  })

  it('should parse x-www-form-urlencoded', function (done) {
    request(this.app)
      .post('/')
      .set('Content-Type', 'application/x-www-form-urlencoded')
      .send('user=tobi')
      .expect(200, '{"user":"tobi"}', done)
  })

  it('should 400 when invalid content-length', function (done) {
    var app = express()

    app.use(function (req, res, next) {
      req.headers['content-length'] = '20' // bad length
      next()
    })

    app.use(express.urlencoded())

    app.post('/', function (req, res) {
      res.json(req.body)
    })

    request(app)
      .post('/')
      .set('Content-Type', 'application/x-www-form-urlencoded')
      .send('str=')
      .expect(400, /content length/, done)
  })

  it('should handle Content-Length: 0', function (done) {
    request(this.app)
      .post('/')
      .set('Content-Type', 'application/x-www-form-urlencoded')
      .set('Content-Length', '0')
      .send('')
      .expect(200, '{}', done)
  })

  it('should handle empty message-body', function (done) {
    request(createApp({ limit: '1kb' }))
      .post('/')
      .set('Content-Type', 'application/x-www-form-urlencoded')
      .set('Transfer-Encoding', 'chunked')
      .send('')
      .expect(200, '{}', done)
  })

  it('should handle duplicated middleware', function (done) {
    var app = express()

    app.use(express.urlencoded())
    app.use(express.urlencoded())

    app.post('/', function (req, res) {
      res.json(req.body)
    })

    request(app)
      .post('/')
      .set('Content-Type', 'application/x-www-form-urlencoded')
      .send('user=tobi')
      .expect(200, '{"user":"tobi"}', done)
  })

  it('should not parse extended syntax', function (done) {
    request(this.app)
      .post('/')
      .set('Content-Type', 'application/x-www-form-urlencoded')
      .send('user[name][first]=Tobi')
      .expect(200, '{"user[name][first]":"Tobi"}', done)
  })

  describe('with extended option', function () {
    describe('when false', function () {
      before(function () {
        this.app = createApp({ extended: false })
      })

      it('should not parse extended syntax', function (done) {
        request(this.app)
          .post('/')
          .set('Content-Type', 'application/x-www-form-urlencoded')
          .send('user[name][first]=Tobi')
          .expect(200, '{"user[name][first]":"Tobi"}', done)
      })

      it('should parse multiple key instances', function (done) {
        request(this.app)
          .post('/')
          .set('Content-Type', 'application/x-www-form-urlencoded')
          .send('user=Tobi&user=Loki')
          .expect(200, '{"user":["Tobi","Loki"]}', done)
      })
    })

    describe('when true', function () {
      before(function () {
        this.app = createApp({ extended: true })
      })

      it('should parse multiple key instances', function (done) {
        request(this.app)
          .post('/')
          .set('Content-Type', 'application/x-www-form-urlencoded')
          .send('user=Tobi&user=Loki')
          .expect(200, '{"user":["Tobi","Loki"]}', done)
      })

      it('should parse extended syntax', function (done) {
        request(this.app)
          .post('/')
          .set('Content-Type', 'application/x-www-form-urlencoded')
          .send('user[name][first]=Tobi')
          .expect(200, '{"user":{"name":{"first":"Tobi"}}}', done)
      })

      it('should parse parameters with dots', function (done) {
        request(this.app)
          .post('/')
          .set('Content-Type', 'application/x-www-form-urlencoded')
          .send('user.name=Tobi')
          .expect(200, '{"user.name":"Tobi"}', done)
      })

      it('should parse fully-encoded extended syntax', function (done) {
        request(this.app)
          .post('/')
          .set('Content-Type', 'application/x-www-form-urlencoded')
          .send('user%5Bname%5D%5Bfirst%5D=Tobi')
          .expect(200, '{"user":{"name":{"first":"Tobi"}}}', done)
      })

      it('should parse array index notation', function (done) {
        request(this.app)
          .post('/')
          .set('Content-Type', 'application/x-www-form-urlencoded')
          .send('foo[0]=bar&foo[1]=baz')
          .expect(200, '{"foo":["bar","baz"]}', done)
      })

      it('should parse array index notation with large array', function (done) {
        var str = 'f[0]=0'

        for (var i = 1; i < 500; i++) {
          str += '&f[' + i + ']=' + i.toString(16)
        }

        request(this.app)
          .post('/')
          .set('Content-Type', 'application/x-www-form-urlencoded')
          .send(str)
          .expect(function (res) {
            var obj = JSON.parse(res.text)
            assert.strictEqual(Object.keys(obj).length, 1)
            assert.strictEqual(Array.isArray(obj.f), true)
            assert.strictEqual(obj.f.length, 500)
          })
          .expect(200, done)
      })

      it('should parse array of objects syntax', function (done) {
        request(this.app)
          .post('/')
          .set('Content-Type', 'application/x-www-form-urlencoded')
          .send('foo[0][bar]=baz&foo[0][fizz]=buzz&foo[]=done!')
          .expect(200, '{"foo":[{"bar":"baz","fizz":"buzz"},"done!"]}', done)
      })

      it('should parse deep object', function (done) {
        var str = 'foo'

        for (var i = 0; i < 32; i++) {
          str += '[p]'
        }

        str += '=bar'

        request(this.app)
          .post('/')
          .set('Content-Type', 'application/x-www-form-urlencoded')
          .send(str)
          .expect(function (res) {
            var obj = JSON.parse(res.text)
            assert.strictEqual(Object.keys(obj).length, 1)
            assert.strictEqual(typeof obj.foo, 'object')

            var depth = 0
            var ref = obj.foo
            while ((ref = ref.p)) { depth++ }
            assert.strictEqual(depth, 32)
          })
          .expect(200, done)
      })
    })
  })

  describe('with inflate option', function () {
    describe('when false', function () {
      before(function () {
        this.app = createApp({ inflate: false })
      })

      it('should not accept content-encoding', function (done) {
        var test = request(this.app).post('/')
        test.set('Content-Encoding', 'gzip')
        test.set('Content-Type', 'application/x-www-form-urlencoded')
        test.write(Buffer.from('1f8b080000000000000bcb4bcc4db57db16e170099a4bad608000000', 'hex'))
        test.expect(415, '[encoding.unsupported] content encoding unsupported', done)
      })
    })

    describe('when true', function () {
      before(function () {
        this.app = createApp({ inflate: true })
      })

      it('should accept content-encoding', function (done) {
        var test = request(this.app).post('/')
        test.set('Content-Encoding', 'gzip')
        test.set('Content-Type', 'application/x-www-form-urlencoded')
        test.write(Buffer.from('1f8b080000000000000bcb4bcc4db57db16e170099a4bad608000000', 'hex'))
        test.expect(200, '{"name":"论"}', done)
      })
    })
  })

  describe('with limit option', function () {
    it('should 413 when over limit with Content-Length', function (done) {
      var buf = Buffer.alloc(1024, '.')
      request(createApp({ limit: '1kb' }))
        .post('/')
        .set('Content-Type', 'application/x-www-form-urlencoded')
        .set('Content-Length', '1028')
        .send('str=' + buf.toString())
        .expect(413, done)
    })

    it('should 413 when over limit with chunked encoding', function (done) {
      var app = createApp({ limit: '1kb' })
      var buf = Buffer.alloc(1024, '.')
      var test = request(app).post('/')
      test.set('Content-Type', 'application/x-www-form-urlencoded')
      test.set('Transfer-Encoding', 'chunked')
      test.write('str=')
      test.write(buf.toString())
      test.expect(413, done)
    })

    it('should 413 when inflated body over limit', function (done) {
      var app = createApp({ limit: '1kb' })
      var test = request(app).post('/')
      test.set('Content-Encoding', 'gzip')
      test.set('Content-Type', 'application/x-www-form-urlencoded')
      test.write(Buffer.from('1f8b080000000000000a2b2e29b2d51b05a360148c580000a0351f9204040000', 'hex'))
      test.expect(413, done)
    })

    it('should accept number of bytes', function (done) {
      var buf = Buffer.alloc(1024, '.')
      request(createApp({ limit: 1024 }))
        .post('/')
        .set('Content-Type', 'application/x-www-form-urlencoded')
        .send('str=' + buf.toString())
        .expect(413, done)
    })

    it('should not change when options altered', function (done) {
      var buf = Buffer.alloc(1024, '.')
      var options = { limit: '1kb' }
      var app = createApp(options)

      options.limit = '100kb'

      request(app)
        .post('/')
        .set('Content-Type', 'application/x-www-form-urlencoded')
        .send('str=' + buf.toString())
        .expect(413, done)
    })

    it('should not hang response', function (done) {
      var app = createApp({ limit: '8kb' })
      var buf = Buffer.alloc(10240, '.')
      var test = request(app).post('/')
      test.set('Content-Type', 'application/x-www-form-urlencoded')
      test.write(buf)
      test.write(buf)
      test.write(buf)
      test.expect(413, done)
    })

    it('should not error when inflating', function (done) {
      var app = createApp({ limit: '1kb' })
      var test = request(app).post('/')
      test.set('Content-Encoding', 'gzip')
      test.set('Content-Type', 'application/x-www-form-urlencoded')
      test.write(Buffer.from('1f8b080000000000000a2b2e29b2d51b05a360148c580000a0351f92040400', 'hex'))
      test.expect(413, done)
    })
  })

  describe('with parameterLimit option', function () {
    describe('with extended: false', function () {
      it('should reject 0', function () {
        assert.throws(createApp.bind(null, { extended: false, parameterLimit: 0 }),
          /TypeError: option parameterLimit must be a positive number/)
      })

      it('should reject string', function () {
        assert.throws(createApp.bind(null, { extended: false, parameterLimit: 'beep' }),
          /TypeError: option parameterLimit must be a positive number/)
      })

      it('should 413 if over limit', function (done) {
        request(createApp({ extended: false, parameterLimit: 10 }))
          .post('/')
          .set('Content-Type', 'application/x-www-form-urlencoded')
          .send(createManyParams(11))
          .expect(413, '[parameters.too.many] too many parameters', done)
      })

      it('should work when at the limit', function (done) {
        request(createApp({ extended: false, parameterLimit: 10 }))
          .post('/')
          .set('Content-Type', 'application/x-www-form-urlencoded')
          .send(createManyParams(10))
          .expect(expectKeyCount(10))
          .expect(200, done)
      })

      it('should work if number is floating point', function (done) {
        request(createApp({ extended: false, parameterLimit: 10.1 }))
          .post('/')
          .set('Content-Type', 'application/x-www-form-urlencoded')
          .send(createManyParams(11))
          .expect(413, /too many parameters/, done)
      })

      it('should work with large limit', function (done) {
        request(createApp({ extended: false, parameterLimit: 5000 }))
          .post('/')
          .set('Content-Type', 'application/x-www-form-urlencoded')
          .send(createManyParams(5000))
          .expect(expectKeyCount(5000))
          .expect(200, done)
      })

      it('should work with Infinity limit', function (done) {
        request(createApp({ extended: false, parameterLimit: Infinity }))
          .post('/')
          .set('Content-Type', 'application/x-www-form-urlencoded')
          .send(createManyParams(10000))
          .expect(expectKeyCount(10000))
          .expect(200, done)
      })
    })

    describe('with extended: true', function () {
      it('should reject 0', function () {
        assert.throws(createApp.bind(null, { extended: true, parameterLimit: 0 }),
          /TypeError: option parameterLimit must be a positive number/)
      })

      it('should reject string', function () {
        assert.throws(createApp.bind(null, { extended: true, parameterLimit: 'beep' }),
          /TypeError: option parameterLimit must be a positive number/)
      })

      it('should 413 if over limit', function (done) {
        request(createApp({ extended: true, parameterLimit: 10 }))
          .post('/')
          .set('Content-Type', 'application/x-www-form-urlencoded')
          .send(createManyParams(11))
          .expect(413, '[parameters.too.many] too many parameters', done)
      })

      it('should work when at the limit', function (done) {
        request(createApp({ extended: true, parameterLimit: 10 }))
          .post('/')
          .set('Content-Type', 'application/x-www-form-urlencoded')
          .send(createManyParams(10))
          .expect(expectKeyCount(10))
          .expect(200, done)
      })

      it('should work if number is floating point', function (done) {
        request(createApp({ extended: true, parameterLimit: 10.1 }))
          .post('/')
          .set('Content-Type', 'application/x-www-form-urlencoded')
          .send(createManyParams(11))
          .expect(413, /too many parameters/, done)
      })

      it('should work with large limit', function (done) {
        request(createApp({ extended: true, parameterLimit: 5000 }))
          .post('/')
          .set('Content-Type', 'application/x-www-form-urlencoded')
          .send(createManyParams(5000))
          .expect(expectKeyCount(5000))
          .expect(200, done)
      })

      it('should work with Infinity limit', function (done) {
        request(createApp({ extended: true, parameterLimit: Infinity }))
          .post('/')
          .set('Content-Type', 'application/x-www-form-urlencoded')
          .send(createManyParams(10000))
          .expect(expectKeyCount(10000))
          .expect(200, done)
      })
    })
  })

  describe('with type option', function () {
    describe('when "application/vnd.x-www-form-urlencoded"', function () {
      before(function () {
        this.app = createApp({ type: 'application/vnd.x-www-form-urlencoded' })
      })

      it('should parse for custom type', function (done) {
        request(this.app)
          .post('/')
          .set('Content-Type', 'application/vnd.x-www-form-urlencoded')
          .send('user=tobi')
          .expect(200, '{"user":"tobi"}', done)
      })

      it('should ignore standard type', function (done) {
        request(this.app)
          .post('/')
          .set('Content-Type', 'application/x-www-form-urlencoded')
          .send('user=tobi')
          .expect(200, '', done)
      })
    })

    describe('when ["urlencoded", "application/x-pairs"]', function () {
      before(function () {
        this.app = createApp({
          type: ['urlencoded', 'application/x-pairs']
        })
      })

      it('should parse "application/x-www-form-urlencoded"', function (done) {
        request(this.app)
          .post('/')
          .set('Content-Type', 'application/x-www-form-urlencoded')
          .send('user=tobi')
          .expect(200, '{"user":"tobi"}', done)
      })

      it('should parse "application/x-pairs"', function (done) {
        request(this.app)
          .post('/')
          .set('Content-Type', 'application/x-pairs')
          .send('user=tobi')
          .expect(200, '{"user":"tobi"}', done)
      })

      it('should ignore application/x-foo', function (done) {
        request(this.app)
          .post('/')
          .set('Content-Type', 'application/x-foo')
          .send('user=tobi')
          .expect(200, '', done)
      })
    })

    describe('when a function', function () {
      it('should parse when truthy value returned', function (done) {
        var app = createApp({ type: accept })

        function accept (req) {
          return req.headers['content-type'] === 'application/vnd.something'
        }

        request(app)
          .post('/')
          .set('Content-Type', 'application/vnd.something')
          .send('user=tobi')
          .expect(200, '{"user":"tobi"}', done)
      })

      it('should work without content-type', function (done) {
        var app = createApp({ type: accept })

        function accept (req) {
          return true
        }

        var test = request(app).post('/')
        test.write('user=tobi')
        test.expect(200, '{"user":"tobi"}', done)
      })

      it('should not invoke without a body', function (done) {
        var app = createApp({ type: accept })

        function accept (req) {
          throw new Error('oops!')
        }

        request(app)
          .get('/')
          .expect(404, done)
      })
    })
  })

  describe('with verify option', function () {
    it('should assert value if function', function () {
      assert.throws(createApp.bind(null, { verify: 'lol' }),
        /TypeError: option verify must be function/)
    })

    it('should error from verify', function (done) {
      var app = createApp({
        verify: function (req, res, buf) {
          if (buf[0] === 0x20) throw new Error('no leading space')
        }
      })

      request(app)
        .post('/')
        .set('Content-Type', 'application/x-www-form-urlencoded')
        .send(' user=tobi')
        .expect(403, '[entity.verify.failed] no leading space', done)
    })

    it('should allow custom codes', function (done) {
      var app = createApp({
        verify: function (req, res, buf) {
          if (buf[0] !== 0x20) return
          var err = new Error('no leading space')
          err.status = 400
          throw err
        }
      })

      request(app)
        .post('/')
        .set('Content-Type', 'application/x-www-form-urlencoded')
        .send(' user=tobi')
        .expect(400, '[entity.verify.failed] no leading space', done)
    })

    it('should allow custom type', function (done) {
      var app = createApp({
        verify: function (req, res, buf) {
          if (buf[0] !== 0x20) return
          var err = new Error('no leading space')
          err.type = 'foo.bar'
          throw err
        }
      })

      request(app)
        .post('/')
        .set('Content-Type', 'application/x-www-form-urlencoded')
        .send(' user=tobi')
        .expect(403, '[foo.bar] no leading space', done)
    })

    it('should allow pass-through', function (done) {
      var app = createApp({
        verify: function (req, res, buf) {
          if (buf[0] === 0x5b) throw new Error('no arrays')
        }
      })

      request(app)
        .post('/')
        .set('Content-Type', 'application/x-www-form-urlencoded')
        .send('user=tobi')
        .expect(200, '{"user":"tobi"}', done)
    })

    it('should 415 on unknown charset prior to verify', function (done) {
      var app = createApp({
        verify: function (req, res, buf) {
          throw new Error('unexpected verify call')
        }
      })

      var test = request(app).post('/')
      test.set('Content-Type', 'application/x-www-form-urlencoded; charset=x-bogus')
      test.write(Buffer.from('00000000', 'hex'))
      test.expect(415, '[charset.unsupported] unsupported charset "X-BOGUS"', done)
    })
  })

  describe('async local storage', function () {
    before(function () {
      var app = express()
      var store = { foo: 'bar' }

      app.use(function (req, res, next) {
        req.asyncLocalStorage = new AsyncLocalStorage()
        req.asyncLocalStorage.run(store, next)
      })

      app.use(express.urlencoded())

      app.use(function (req, res, next) {
        var local = req.asyncLocalStorage.getStore()

        if (local) {
          res.setHeader('x-store-foo', String(local.foo))
        }

        next()
      })

      app.use(function (err, req, res, next) {
        var local = req.asyncLocalStorage.getStore()

        if (local) {
          res.setHeader('x-store-foo', String(local.foo))
        }

        res.status(err.status || 500)
        res.send('[' + err.type + '] ' + err.message)
      })

      app.post('/', function (req, res) {
        res.json(req.body)
      })

      this.app = app
    })

    it('should persist store', function (done) {
      request(this.app)
        .post('/')
        .set('Content-Type', 'application/x-www-form-urlencoded')
        .send('user=tobi')
        .expect(200)
        .expect('x-store-foo', 'bar')
        .expect('{"user":"tobi"}')
        .end(done)
    })

    it('should persist store when unmatched content-type', function (done) {
      request(this.app)
        .post('/')
        .set('Content-Type', 'application/fizzbuzz')
        .send('buzz')
        .expect(200)
        .expect('x-store-foo', 'bar')
        .end(done)
    })

    it('should persist store when inflated', function (done) {
      var test = request(this.app).post('/')
      test.set('Content-Encoding', 'gzip')
      test.set('Content-Type', 'application/x-www-form-urlencoded')
      test.write(Buffer.from('1f8b080000000000000bcb4bcc4db57db16e170099a4bad608000000', 'hex'))
      test.expect(200)
      test.expect('x-store-foo', 'bar')
      test.expect('{"name":"论"}')
      test.end(done)
    })

    it('should persist store when inflate error', function (done) {
      var test = request(this.app).post('/')
      test.set('Content-Encoding', 'gzip')
      test.set('Content-Type', 'application/x-www-form-urlencoded')
      test.write(Buffer.from('1f8b080000000000000bcb4bcc4db57db16e170099a4bad6080000', 'hex'))
      test.expect(400)
      test.expect('x-store-foo', 'bar')
      test.end(done)
    })

    it('should persist store when limit exceeded', function (done) {
      request(this.app)
        .post('/')
        .set('Content-Type', 'application/x-www-form-urlencoded')
        .send('user=' + Buffer.alloc(1024 * 100, '.').toString())
        .expect(413)
        .expect('x-store-foo', 'bar')
        .end(done)
    })
  })

  describe('charset', function () {
    before(function () {
      this.app = createApp()
    })

    it('should parse utf-8', function (done) {
      var test = request(this.app).post('/')
      test.set('Content-Type', 'application/x-www-form-urlencoded; charset=utf-8')
      test.write(Buffer.from('6e616d653de8aeba', 'hex'))
      test.expect(200, '{"name":"论"}', done)
    })

    it('should parse when content-length != char length', function (done) {
      var test = request(this.app).post('/')
      test.set('Content-Type', 'application/x-www-form-urlencoded; charset=utf-8')
      test.set('Content-Length', '7')
      test.write(Buffer.from('746573743dc3a5', 'hex'))
      test.expect(200, '{"test":"å"}', done)
    })

    it('should default to utf-8', function (done) {
      var test = request(this.app).post('/')
      test.set('Content-Type', 'application/x-www-form-urlencoded')
      test.write(Buffer.from('6e616d653de8aeba', 'hex'))
      test.expect(200, '{"name":"论"}', done)
    })

    it('should fail on unknown charset', function (done) {
      var test = request(this.app).post('/')
      test.set('Content-Type', 'application/x-www-form-urlencoded; charset=koi8-r')
      test.write(Buffer.from('6e616d653dcec5d4', 'hex'))
      test.expect(415, '[charset.unsupported] unsupported charset "KOI8-R"', done)
    })
  })

  describe('encoding', function () {
    before(function () {
      this.app = createApp({ limit: '10kb' })
    })

    it('should parse without encoding', function (done) {
      var test = request(this.app).post('/')
      test.set('Content-Type', 'application/x-www-form-urlencoded')
      test.write(Buffer.from('6e616d653de8aeba', 'hex'))
      test.expect(200, '{"name":"论"}', done)
    })

    it('should support identity encoding', function (done) {
      var test = request(this.app).post('/')
      test.set('Content-Encoding', 'identity')
      test.set('Content-Type', 'application/x-www-form-urlencoded')
      test.write(Buffer.from('6e616d653de8aeba', 'hex'))
      test.expect(200, '{"name":"论"}', done)
    })

    it('should support gzip encoding', function (done) {
      var test = request(this.app).post('/')
      test.set('Content-Encoding', 'gzip')
      test.set('Content-Type', 'application/x-www-form-urlencoded')
      test.write(Buffer.from('1f8b080000000000000bcb4bcc4db57db16e170099a4bad608000000', 'hex'))
      test.expect(200, '{"name":"论"}', done)
    })

    it('should support deflate encoding', function (done) {
      var test = request(this.app).post('/')
      test.set('Content-Encoding', 'deflate')
      test.set('Content-Type', 'application/x-www-form-urlencoded')
      test.write(Buffer.from('789ccb4bcc4db57db16e17001068042f', 'hex'))
      test.expect(200, '{"name":"论"}', done)
    })

    it('should be case-insensitive', function (done) {
      var test = request(this.app).post('/')
      test.set('Content-Encoding', 'GZIP')
      test.set('Content-Type', 'application/x-www-form-urlencoded')
      test.write(Buffer.from('1f8b080000000000000bcb4bcc4db57db16e170099a4bad608000000', 'hex'))
      test.expect(200, '{"name":"论"}', done)
    })

    it('should 415 on unknown encoding', function (done) {
      var test = request(this.app).post('/')
      test.set('Content-Encoding', 'nulls')
      test.set('Content-Type', 'application/x-www-form-urlencoded')
      test.write(Buffer.from('000000000000', 'hex'))
      test.expect(415, '[encoding.unsupported] unsupported content encoding "nulls"', done)
    })
  })
})

function createManyParams (count) {
  var str = ''

  if (count === 0) {
    return str
  }

  str += '0=0'

  for (var i = 1; i < count; i++) {
    var n = i.toString(36)
    str += '&' + n + '=' + n
  }

  return str
}

function createApp (options) {
  var app = express()

  app.use(express.urlencoded(options))

  app.use(function (err, req, res, next) {
    res.status(err.status || 500)
    res.send(String(req.headers['x-error-property']
      ? err[req.headers['x-error-property']]
      : ('[' + err.type + '] ' + err.message)))
  })

  app.post('/', function (req, res) {
    res.json(req.body)
  })

  return app
}

function expectKeyCount (count) {
  return function (res) {
    assert.strictEqual(Object.keys(JSON.parse(res.text)).length, count)
  }
}

import re

from jinja2.exceptions import TemplateSyntaxError
from jinja2.ext import Extension
from jinja2.lexer import count_newlines
from jinja2.lexer import Token

_outside_re = re.compile(r"\\?(gettext|_)\(")
_inside_re = re.compile(r"\\?[()]")


class InlineGettext(Extension):
    """This extension implements support for inline gettext blocks::

        <h1>_(Welcome)</h1>
        <p>_(This is a paragraph)</p>

    Requires the i18n extension to be loaded and configured.
    """

    def filter_stream(self, stream):
        paren_stack = 0

        for token in stream:
            if token.type != "data":
                yield token
                continue

            pos = 0
            lineno = token.lineno

            while True:
                if not paren_stack:
                    match = _outside_re.search(token.value, pos)
                else:
                    match = _inside_re.search(token.value, pos)
                if match is None:
                    break
                new_pos = match.start()
                if new_pos > pos:
                    preval = token.value[pos:new_pos]
                    yield Token(lineno, "data", preval)
                    lineno += count_newlines(preval)
                gtok = match.group()
                if gtok[0] == "\\":
                    yield Token(lineno, "data", gtok[1:])
                elif not paren_stack:
                    yield Token(lineno, "block_begin", None)
                    yield Token(lineno, "name", "trans")
                    yield Token(lineno, "block_end", None)
                    paren_stack = 1
                else:
                    if gtok == "(" or paren_stack > 1:
                        yield Token(lineno, "data", gtok)
                    paren_stack += -1 if gtok == ")" else 1
                    if not paren_stack:
                        yield Token(lineno, "block_begin", None)
                        yield Token(lineno, "name", "endtrans")
                        yield Token(lineno, "block_end", None)
                pos = match.end()

            if pos < len(token.value):
                yield Token(lineno, "data", token.value[pos:])

        if paren_stack:
            raise TemplateSyntaxError(
                "unclosed gettext expression",
                token.lineno,
                stream.name,
                stream.filename,
            )

<!doctype html>
<html lang="en">
  <head>
    <meta charset="utf-8">
    <title>lodash-fp Test Suite</title>
    <link rel="stylesheet" href="../node_modules/qunitjs/qunit/qunit.css">
  </head>
  <body>
    <script>
      // Avoid reporting tests to Sauce Labs when script errors occur.
      if (location.port == '9001') {
        window.onerror = function(message) {
          if (window.QUnit) {
            QUnit.config.done.length = 0;
          }
          global_test_results = { 'message': message };
        };
      }
    </script>
    <script src="../lodash.js"></script>
    <script src="../dist/lodash.fp.js"></script>
    <script src="../dist/mapping.fp.js"></script>
    <script src="../node_modules/qunitjs/qunit/qunit.js"></script>
    <script src="../node_modules/qunit-extras/qunit-extras.js"></script>
    <script src="../node_modules/platform/platform.js"></script>
    <script src="./test-fp.js"></script>
    <div id="qunit"></div>
    <script>
      // Set a more readable browser name.
      window.onload = function() {
        var timeoutId = setInterval(function() {
          var ua = document.getElementById('qunit-userAgent');
          if (ua) {
            ua.innerHTML = platform;
            clearInterval(timeoutId);
          }
        }, 16);
      };
    </script>
  </body>
</html>

import click


def test_filename_formatting():
    assert click.format_filename(b"foo.txt") == "foo.txt"
    assert click.format_filename(b"/x/foo.txt") == "/x/foo.txt"
    assert click.format_filename("/x/foo.txt") == "/x/foo.txt"
    assert click.format_filename("/x/foo.txt", shorten=True) == "foo.txt"
    assert click.format_filename("/x/\ufffd.txt", shorten=True) == "�.txt"

name: Package Manager Builds

on: [push, pull_request]

jobs:
  conan_builds:
    name: Conan ${{matrix.conan_version}}
    runs-on: ubuntu-22.04
    strategy:
      matrix:
        conan_version:
          - '1.63'
          - '2.1'

        include:
          # Conan 1 has default profiles installed
          - conan_version: '1.63'
            profile_generate: 'false'

    steps:
    - uses: actions/checkout@v6

    - name: Install conan
      run: pip install conan==${{matrix.conan_version}}

    - name: Setup conan profiles
      if: matrix.profile_generate != 'false'
      run: conan profile detect

    - name: Run conan package create
      run: conan create . -tf .conan/test_package

coverage:
  precision: 2
  round: nearest
  range: "60...90"
  status:
    project:
      default:
        threshold: 2%
    patch:
      default:
        target: 80%
  ignore:
    - "**/external/clara.hpp"
    - "tests"


codecov:
  branch: devel
  max_report_age: off

comment:
  layout: "diff"

'use strict'

var assert = require('node:assert')
var express = require('../');
var request = require('supertest');

describe('middleware', function(){
  describe('.next()', function(){
    it('should behave like connect', function(done){
      var app = express()
        , calls = [];

      app.use(function(req, res, next){
        calls.push('one');
        next();
      });

      app.use(function(req, res, next){
        calls.push('two');
        next();
      });

      app.use(function(req, res){
        var buf = '';
        res.setHeader('Content-Type', 'application/json');
        req.setEncoding('utf8');
        req.on('data', function(chunk){ buf += chunk });
        req.on('end', function(){
          res.end(buf);
        });
      });

      request(app)
      .get('/')
      .set('Content-Type', 'application/json')
      .send('{"foo":"bar"}')
      .expect('Content-Type', 'application/json')
      .expect(function () { assert.deepEqual(calls, ['one', 'two']) })
      .expect(200, '{"foo":"bar"}', done)
    })
  })
})

<a id="top"></a>
# Reporter events

**Contents**<br>
[Test running events](#test-running-events)<br>
[Benchmarking events](#benchmarking-events)<br>
[Listings events](#listings-events)<br>
[Miscellaneous events](#miscellaneous-events)<br>

Reporter events are one of the customization points for user code. They
are used by [reporters](reporters.md#top) to customize Catch2's output,
and by [event listeners](event-listeners.md#top) to perform in-process
actions under some conditions.

There are currently 21 reporter events in Catch2, split between 4 distinct
event groups:
* test running events (10 events)
* benchmarking (4 events)
* listings (3 events)
* miscellaneous (4 events)

## Test running events

Test running events are always paired so that for each `fooStarting` event,
there is a `fooEnded` event. This means that the 10 test running events
consist of 5 pairs of events:

* `testRunStarting` and `testRunEnded`,
* `testCaseStarting` and `testCaseEnded`,
* `testCasePartialStarting` and `testCasePartialEnded`,
* `sectionStarting` and `sectionEnded`,
* `assertionStarting` and `assertionEnded`

### `testRun` events

```cpp
void testRunStarting( TestRunInfo const& testRunInfo );
void testRunEnded( TestRunStats const& testRunStats );
```

The `testRun` events bookend the entire test run. `testRunStarting` is
emitted before the first test case is executed, and `testRunEnded` is
emitted after all the test cases have been executed.

### `testCase` events

```cpp
void testCaseStarting( TestCaseInfo const& testInfo );
void testCaseEnded( TestCaseStats const& testCaseStats );
```

The `testCase` events bookend one _full_ run of a specific test case.
Individual runs through a test case, e.g. due to `SECTION`s or `GENERATE`s,
are handled by a different event.


### `testCasePartial` events

> Introduced in Catch2 3.0.1

```cpp
void testCasePartialStarting( TestCaseInfo const& testInfo, uint64_t partNumber );
void testCasePartialEnded(TestCaseStats const& testCaseStats, uint64_t partNumber );
```

`testCasePartial` events bookend one _partial_ run of a specific test case.
This means that for any given test case, these events can be emitted
multiple times, e.g. due to multiple leaf sections.

In regards to nesting with `testCase` events, `testCasePartialStarting`
will never be emitted before the corresponding `testCaseStarting`, and
`testCasePartialEnded` will always be emitted before the corresponding
`testCaseEnded`.


### `section` events

```cpp
void sectionStarting( SectionInfo const& sectionInfo );
void sectionEnded( SectionStats const& sectionStats );
```

`section` events are emitted only for active `SECTION`s, that is, sections
that are entered. Sections that are skipped in this test case run-through
do not cause events to be emitted.

_Note that test cases always contain one implicit section. The event for
this section is emitted after the corresponding `testCasePartialStarting`
event._


### `assertion` events

```cpp
void assertionStarting( AssertionInfo const& assertionInfo );
void assertionEnded( AssertionStats const& assertionStats );
```

The `assertionStarting` event is emitted before the expression in the
assertion is captured or evaluated and `assertionEnded` is emitted
afterwards. This means that given assertion like `REQUIRE(a + b == c + d)`,
Catch2 first emits `assertionStarting` event, then `a + b` and `c + d`
are evaluated, then their results are captured, the comparison is evaluated,
and then `assertionEnded` event is emitted.


## Benchmarking events

> [Introduced](https://github.com/catchorg/Catch2/issues/1616) in Catch2 2.9.0.

```cpp
void benchmarkPreparing( StringRef name ) override;
void benchmarkStarting( BenchmarkInfo const& benchmarkInfo ) override;
void benchmarkEnded( BenchmarkStats<> const& benchmarkStats ) override;
void benchmarkFailed( StringRef error ) override;
```

Due to the benchmark lifecycle being bit more complicated, the benchmarking
events have their own category, even though they could be seen as parallel
to the `assertion*` events. You should expect running a benchmark to
generate at least 2 of the events above.

To understand the explanation below, you should read the [benchmarking
documentation](benchmarks.md#top) first.

* `benchmarkPreparing` event is sent after the environmental probe
finishes, but before the user code is first estimated.
* `benchmarkStarting` event is sent after the user code is estimated,
but has not been benchmarked yet.
* `benchmarkEnded` event is sent after the user code has been benchmarked,
and contains the benchmarking results.
* `benchmarkFailed` event is sent if either the estimation or the
benchmarking itself fails.


## Listings events

> Introduced in Catch2 3.0.1.

Listings events are events that correspond to the test binary being
invoked with `--list-foo` flag.

There are currently 3 listing events, one for reporters, one for tests,
and one for tags. Note that they are not exclusive to each other.

```cpp
void listReporters( std::vector<ReporterDescription> const& descriptions );
void listTests( std::vector<TestCaseHandle> const& tests );
void listTags( std::vector<TagInfo> const& tagInfos );
```


## Miscellaneous events

```cpp
void reportInvalidTestSpec( StringRef unmatchedSpec );
void fatalErrorEncountered( StringRef error );
void noMatchingTestCases( StringRef unmatchedSpec );
```

These are one-off events that do not neatly fit into other categories.

`reportInvalidTestSpec` is sent for each [test specification command line
argument](command-line.md#specifying-which-tests-to-run) that wasn't
parsed into a valid spec.

`fatalErrorEncountered` is sent when Catch2's POSIX signal handling
or Windows SE handler is called into with a fatal signal/exception.

`noMatchingTestCases` is sent for each user provided test specification
that did not match any registered tests.

---

[Home](Readme.md#top)

'use strict'

var express = require('../')
  , request = require('supertest');

describe('req', function(){
  describe('.path', function(){
    it('should return the parsed pathname', function(done){
      var app = express();

      app.use(function(req, res){
        res.end(req.path);
      });

      request(app)
      .get('/login?redirect=/post/1/comments')
      .expect('/login', done);
    })
  })
})

<a id="top"></a>
# Open Source projects using Catch2

Catch2 is great for open source. It is licensed under the [Boost Software
License (BSL)](../LICENSE.txt), has no further dependencies and supports
two file distribution.

As a result, Catch2 is used for testing in many different Open Source
projects. This page lists at least some of them, even though it will
obviously never be complete (and does not have the ambition to be
complete). Note that the list below is intended to be in alphabetical
order, to avoid implications of relative importance of the projects.

_Please only add projects here if you are their maintainer, or have the
maintainer's explicit consent._


## Libraries & Frameworks

### [accessorpp](https://github.com/wqking/accessorpp)
C++ library for implementing property and data binding.

### [alpaka](https://github.com/alpaka-group/alpaka)
A header-only C++14 abstraction library for accelerator development.

### [ApprovalTests.cpp](https://github.com/approvals/ApprovalTests.cpp)
C++11 implementation of Approval Tests, for quick, convenient testing of legacy code.

### [args](https://github.com/Taywee/args)
A simple header-only C++ argument parser library.

### [Azmq](https://github.com/zeromq/azmq)
Boost Asio style bindings for ZeroMQ.

### [Cataclysm: Dark Days Ahead](https://github.com/CleverRaven/Cataclysm-DDA)
Post-apocalyptic survival RPG.

### [ChaiScript](https://github.com/ChaiScript/ChaiScript)
A, header-only, embedded scripting language designed from the ground up to directly target C++ and take advantage of modern C++ development techniques.

### [ChakraCore](https://github.com/Microsoft/ChakraCore)
The core part of the Chakra JavaScript engine that powers Microsoft Edge.

### [Clara](https://github.com/philsquared/Clara)
A, single-header-only, type-safe, command line parser - which also prints formatted usage strings.

### [Couchbase-lite-core](https://github.com/couchbase/couchbase-lite-core)
The next-generation core storage and query engine for Couchbase Lite.

### [cppcodec](https://github.com/tplgy/cppcodec)
Header-only C++11 library to encode/decode base64, base64url, base32, base32hex and hex (a.k.a. base16) as specified in RFC 4648, plus Crockford's base32.

### [DtCraft](https://github.com/twhuang-uiuc/DtCraft)
A High-performance Cluster Computing Engine.

### [eventpp](https://github.com/wqking/eventpp)
C++ event library for callbacks, event dispatcher, and event queue. With eventpp you can easily implement signal and slot mechanism, publisher and subscriber pattern, or observer pattern.

### [forest](https://github.com/xorz57/forest)
Template Library of Tree Data Structures.

### [Fuxedo](https://github.com/fuxedo/fuxedo)
Open source Oracle Tuxedo-like XATMI middleware for C and C++.

### [HIP CPU Runtime](https://github.com/ROCm-Developer-Tools/HIP-CPU)
A header-only library that allows CPUs to execute unmodified HIP code. It is generic and does not assume a particular CPU vendor or architecture.

### [Inja](https://github.com/pantor/inja)
A header-only template engine for modern C++.

### [LLAMA](https://github.com/alpaka-group/llama)
A C++17 template header-only library for the abstraction of memory access patterns.

### [libcluon](https://github.com/chrberger/libcluon)
A single-header-only library written in C++14 to glue distributed software components (UDP, TCP, shared memory) supporting natively Protobuf, LCM/ZCM, MsgPack, and JSON for dynamic message transformations in-between.

### [MNMLSTC Core](https://github.com/mnmlstc/core)
A small and easy to use C++11 library that adds a functionality set that will be available in C++14 and later, as well as some useful additions.

### [nanodbc](https://github.com/lexicalunit/nanodbc/)
A small C++ library wrapper for the native C ODBC API.

### [Nonius](https://github.com/libnonius/nonius)
A header-only framework for benchmarking small snippets of C++ code.

### [OpenALpp](https://github.com/Laguna1989/OpenALpp)
A modern OOP C++14 audio library built on OpenAL for Windows, Linux and web (emscripten).

### [polymorphic_value](https://github.com/jbcoe/polymorphic_value)
A polymorphic value-type for C++.

### [Ppconsul](https://github.com/oliora/ppconsul)
A C++ client library for Consul. Consul is a distributed tool for discovering and configuring services in your infrastructure.

### [Reactive-Extensions/ RxCpp](https://github.com/Reactive-Extensions/RxCpp)
A library of algorithms for values-distributed-in-time.

### [SFML](https://github.com/SFML/SFML)
Simple and Fast Multimedia Library.

### [SOCI](https://github.com/SOCI/soci)
The C++ Database Access Library.

### [TextFlowCpp](https://github.com/philsquared/textflowcpp)
A small, single-header-only, library for wrapping and composing columns of text.

### [thor](https://github.com/xorz57/thor)
Wrapper Library for CUDA.

### [toml++](https://github.com/marzer/tomlplusplus)
A header-only TOML parser and serializer for modern C++.

### [Trompeloeil](https://github.com/rollbear/trompeloeil)
A thread-safe header-only mocking framework for C++14.

### [wxWidgets](https://www.wxwidgets.org/)
Cross-Platform C++ GUI Library.

### [xmlwrapp](https://github.com/vslavik/xmlwrapp)
C++ XML parsing library using libxml2.

## Applications & Tools

### [App Mesh](https://github.com/laoshanxi/app-mesh)
A high available cloud native micro-service application management platform implemented by modern C++.

### [ArangoDB](https://github.com/arangodb/arangodb)
ArangoDB is a native multi-model database with flexible data models for documents, graphs, and key-values.

### [Cytopia](https://github.com/CytopiaTeam/Cytopia)
Cytopia is a free, open source retro pixel-art city building game with a big focus on mods. It utilizes a custom isometric rendering engine based on SDL2.

### [d-SEAMS](https://github.com/d-SEAMS/seams-core)
Open source molecular dynamics simulation structure analysis suite of tools in modern C++.

### [Giada - Your Hardcore Loop Machine](https://github.com/monocasual/giada)
Minimal, open-source and cross-platform audio tool for live music production.

### [MAME](https://github.com/mamedev/mame)
MAME originally stood for Multiple Arcade Machine Emulator.

### [Newsbeuter](https://github.com/akrennmair/newsbeuter)
Newsbeuter is an open-source RSS/Atom feed reader for text terminals.

### [PopHead](https://github.com/SPC-Some-Polish-Coders/PopHead)
A 2D, Zombie, RPG game which is being made on our own engine.

### [raspigcd](https://github.com/pantadeusz/raspigcd)
Low level CLI app and library for execution of GCODE on Raspberry Pi without any additional microcontrollers (just RPi + Stepsticks).

### [SpECTRE](https://github.com/sxs-collaboration/spectre)
SpECTRE is a code for multi-scale, multi-physics problems in astrophysics and gravitational physics.

### [Standardese](https://github.com/foonathan/standardese)
Standardese aims to be a nextgen Doxygen.

---

[Home](Readme.md#top)

'use strict'

var express = require('../')
  , request = require('supertest');

describe('throw after .end()', function(){
  it('should fail gracefully', function(done){
    var app = express();

    app.get('/', function(req, res){
      res.end('yay');
      throw new Error('boom');
    });

    request(app)
    .get('/')
    .expect('yay')
    .expect(200, done);
  })
})

import {setTimeout as delay} from 'node:timers/promises';
import is, {assert} from '@sindresorhus/is';
import asPromise from './as-promise/index.js';
import type {
	GotReturn,
	ExtendOptions,
	Got,
	HTTPAlias,
	InstanceDefaults,
	GotPaginate,
	GotStream,
	GotRequestFunction,
	OptionsWithPagination,
	StreamOptions,
} from './types.js';
import Request from './core/index.js';
import type {Response} from './core/response.js';
import Options, {
	applyUrlOverride,
	assertUrlHasSameOriginAsPrefixUrlIfNeeded,
	getUrlPrefixBoundary,
	hasUrlOrPrefixUrlBoundaryChanged,
	isSameOrigin,
	snapshotCrossOriginState,
	type OptionsInit,
} from './core/options.js';
import type {RequestPromise} from './as-promise/types.js';

const isGotInstance = (value: Got | ExtendOptions): value is Got => is.function(value);

const aliases: readonly HTTPAlias[] = [
	'get',
	'post',
	'put',
	'patch',
	'head',
	'delete',
	'query',
];

const optionsObjectUrlErrorMessage = 'The `url` option is not supported in options objects. Pass it as the first argument instead.';

const assertNoUrlInOptionsObject = (options: Record<string, unknown>): void => {
	if (Object.hasOwn(options, 'url')) {
		throw new TypeError(optionsObjectUrlErrorMessage);
	}
};

const cloneWithProperty = <Value extends Record<string, unknown>>(value: Value, property: string, propertyValue: unknown): Value => {
	const clone = Object.create(Object.getPrototypeOf(value), Object.getOwnPropertyDescriptors(value)) as Value;

	Object.defineProperty(clone, property, {
		value: propertyValue,
		enumerable: true,
		configurable: true,
		writable: true,
	});

	return clone;
};

const create = (defaults: InstanceDefaults): Got => {
	defaults = {
		options: new Options(undefined, undefined, defaults.options),
		handlers: [...defaults.handlers],
		mutableDefaults: defaults.mutableDefaults,
	};

	Object.defineProperty(defaults, 'mutableDefaults', {
		enumerable: true,
		configurable: false,
		writable: false,
	});

	const makeRequest = (url: string | URL | OptionsInit | undefined, options: OptionsInit | undefined, defaultOptions: Options, isStream: boolean): GotReturn => {
		if (is.plainObject(url)) {
			assertNoUrlInOptionsObject(url);
		}

		if (is.plainObject(options)) {
			assertNoUrlInOptionsObject(options);
		}

		// `isStream` is skipped by `merge()`, so set it via the direct setter after construction.
		// Avoid a synthetic second merge only for the single-options-object stream form.
		const requestUrl = isStream && is.plainObject(url) ? cloneWithProperty(url, 'isStream', true) : url;
		const requestOptions = isStream && !is.plainObject(url) && options ? cloneWithProperty(options, 'isStream', true) : options;

		const request = new Request(requestUrl, requestOptions, defaultOptions);

		if (isStream && request.options) {
			request.options.isStream = true;
		}

		let promise: RequestPromise | undefined;
		const urlBeforeHandlers = request.options?.url instanceof URL ? new URL(request.options.url) : undefined;
		const boundaryBeforeHandlers = request.options ? getUrlPrefixBoundary(request.options) : undefined;

		const lastHandler = (normalized: Options): GotReturn => {
			if (
				urlBeforeHandlers
				&& boundaryBeforeHandlers
				&& normalized?.url instanceof URL
				&& hasUrlOrPrefixUrlBoundaryChanged(normalized, normalized.url, boundaryBeforeHandlers)
			) {
				assertUrlHasSameOriginAsPrefixUrlIfNeeded(normalized, normalized.url);
			}

			// Note: `options` is `undefined` when `new Options(...)` fails
			request.options = normalized;
			const shouldReturnStream = normalized?.isStream ?? isStream;
			request._noPipe = !shouldReturnStream;
			void request.flush();

			if (shouldReturnStream) {
				return request;
			}

			promise ??= asPromise(request);

			return promise;
		};

		let iteration = 0;
		const iterateHandlers = (newOptions: Options): GotReturn => {
			const handler = defaults.handlers[iteration++] ?? lastHandler;

			const result = handler(newOptions, iterateHandlers) as GotReturn;

			if (is.promise(result) && !request.options?.isStream) {
				promise ??= asPromise(request);

				if (result !== promise) {
					const descriptors = Object.getOwnPropertyDescriptors(promise);

					for (const key in descriptors) {
						if (key in result) {
							// eslint-disable-next-line @typescript-eslint/no-dynamic-delete
							delete descriptors[key];
						}
					}

					// eslint-disable-next-line @typescript-eslint/no-floating-promises
					Object.defineProperties(result, descriptors);
				}
			}

			return result;
		};

		return iterateHandlers(request.options);
	};

	// Got interface
	const got: Got = ((url: string | URL | OptionsInit | undefined, options?: OptionsInit, defaultOptions: Options = defaults.options): GotReturn =>
		makeRequest(url, options, defaultOptions, false)) as Got;

	got.extend = (...instancesOrOptions) => {
		const options = new Options(undefined, undefined, defaults.options);
		const handlers = [...defaults.handlers];

		let mutableDefaults: boolean | undefined;

		for (const value of instancesOrOptions) {
			if (isGotInstance(value)) {
				options.merge(value.defaults.options);
				handlers.push(...value.defaults.handlers);
				mutableDefaults = value.defaults.mutableDefaults;
			} else {
				assertNoUrlInOptionsObject(value);
				options.merge(value);

				if (value.handlers) {
					handlers.push(...value.handlers);
				}

				mutableDefaults = value.mutableDefaults;
			}
		}

		return create({
			options,
			handlers,
			mutableDefaults: Boolean(mutableDefaults),
		});
	};

	// Pagination
	const paginateEach = (async function * <T, R>(url: string | URL, options?: OptionsWithPagination<T, R>): AsyncIterableIterator<T> {
		if (is.plainObject(url)) {
			assertNoUrlInOptionsObject(url);
		}

		if (is.plainObject(options)) {
			assertNoUrlInOptionsObject(options);
		}

		let normalizedOptions = new Options(url, options as OptionsInit, defaults.options);
		normalizedOptions.resolveBodyOnly = false;

		const {pagination} = normalizedOptions;

		assert.function(pagination.transform);
		assert.function(pagination.shouldContinue);
		assert.function(pagination.filter);
		assert.function(pagination.paginate);
		assert.number(pagination.countLimit);
		assert.number(pagination.requestLimit);
		assert.number(pagination.backoff);

		const allItems: T[] = [];
		let {countLimit} = pagination;

		let numberOfRequests = 0;
		while (numberOfRequests < pagination.requestLimit) {
			if (numberOfRequests !== 0) {
				// eslint-disable-next-line no-await-in-loop
				await delay(pagination.backoff);
			}

			// eslint-disable-next-line no-await-in-loop
			const response = (await got(undefined, undefined, normalizedOptions)) as Response;

			// eslint-disable-next-line no-await-in-loop
			const parsed: unknown[] = await pagination.transform(response);
			const currentItems: T[] = [];

			assert.array(parsed);

			for (const item of parsed) {
				if (pagination.filter({item, currentItems, allItems})) {
					if (!pagination.shouldContinue({item, currentItems, allItems})) {
						return;
					}

					yield item as T;

					if (pagination.stackAllItems) {
						allItems.push(item as T);
					}

					currentItems.push(item as T);

					if (--countLimit <= 0) {
						return;
					}
				}
			}

			const requestOptions = response.request.options;
			const previousUrl = requestOptions.url ? new URL(requestOptions.url) : undefined;
			const previousBoundary = getUrlPrefixBoundary(requestOptions);
			const previousState = previousUrl ? snapshotCrossOriginState(requestOptions) : undefined;
			// eslint-disable-next-line no-await-in-loop
			const [optionsToMerge, changedState] = await requestOptions.trackStateMutations(async changedState => [
				pagination.paginate!({
					response,
					currentItems,
					allItems,
				}),
				changedState,
			] as const);

			if (optionsToMerge === false) {
				return;
			}

			if (optionsToMerge === response.request.options) {
				normalizedOptions = response.request.options;
				normalizedOptions.clearUnchangedCookieHeader(previousState, changedState);

				if (previousUrl) {
					const nextUrl = normalizedOptions.url as URL | undefined;
					if (
						nextUrl
						&& hasUrlOrPrefixUrlBoundaryChanged(normalizedOptions, nextUrl, previousBoundary)
					) {
						assertUrlHasSameOriginAsPrefixUrlIfNeeded(normalizedOptions, nextUrl);
					}

					if (nextUrl && !isSameOrigin(previousUrl, nextUrl)) {
						normalizedOptions.prefixUrl = '';
						normalizedOptions.stripUnchangedCrossOriginState(previousState!, changedState);
					}
				}
			} else {
				const paginationOptions = normalizedOptions;
				const paginationUrl = paginationOptions.url instanceof URL ? new URL(paginationOptions.url) : undefined;
				const paginationBoundary = getUrlPrefixBoundary(paginationOptions);
				const hasExplicitBody = (Object.hasOwn(optionsToMerge, 'body') && optionsToMerge.body !== undefined)
					|| (Object.hasOwn(optionsToMerge, 'json') && optionsToMerge.json !== undefined)
					|| (Object.hasOwn(optionsToMerge, 'form') && optionsToMerge.form !== undefined);
				const clearsCookieJar = Object.hasOwn(optionsToMerge, 'cookieJar') && optionsToMerge.cookieJar === undefined;

				if (hasExplicitBody) {
					paginationOptions.clearBody();
				}

				if (clearsCookieJar) {
					paginationOptions.cookieJar = undefined;
				}

				const {url, ...optionsToMergeWithoutUrl} = optionsToMerge;
				paginationOptions.merge(optionsToMergeWithoutUrl);
				paginationOptions.syncCookieHeaderAfterMerge(previousState, optionsToMergeWithoutUrl.headers);

				if (
					paginationOptions.url instanceof URL
					&& hasUrlOrPrefixUrlBoundaryChanged(paginationOptions, paginationOptions.url, paginationBoundary)
				) {
					assertUrlHasSameOriginAsPrefixUrlIfNeeded(paginationOptions, paginationOptions.url);
				}

				if (
					url === undefined
					&& previousUrl
					&& paginationOptions.url instanceof URL
					&& !isSameOrigin(previousUrl, paginationOptions.url)
				) {
					paginationOptions.stripSensitiveHeaders(previousUrl, paginationOptions.url, optionsToMerge);

					if (!hasExplicitBody) {
						paginationOptions.clearBody();
					}
				}

				if (
					previousUrl
					&& paginationUrl
					&& !isSameOrigin(paginationUrl, previousUrl)
				) {
					paginationOptions.stripSensitiveHeaders(paginationUrl, previousUrl, optionsToMerge);

					if (!hasExplicitBody) {
						paginationOptions.clearBody();
					}
				}

				try {
					assert.any([is.string, is.urlInstance, is.undefined], optionsToMerge.url);
				} catch (error) {
					if (error instanceof Error) {
						error.message = `Option 'pagination.paginate.url': ${error.message}`;
					}

					throw error;
				}

				if (url !== undefined) {
					const nextUrl = applyUrlOverride(paginationOptions, url, {
						...optionsToMerge,
						baseUrl: previousUrl,
					});

					if (
						paginationOptions.prefixUrl.toString() !== paginationBoundary.prefixUrl
						|| paginationOptions.allowAbsoluteUrls !== paginationBoundary.allowAbsoluteUrls
					) {
						assertUrlHasSameOriginAsPrefixUrlIfNeeded(paginationOptions, nextUrl);
					}

					if (previousUrl) {
						paginationOptions.stripSensitiveHeaders(previousUrl, nextUrl, optionsToMerge);

						if (!isSameOrigin(previousUrl, nextUrl) && !hasExplicitBody) {
							paginationOptions.clearBody();
						}
					}
				}

				normalizedOptions = paginationOptions;
			}

			numberOfRequests++;
		}
	});

	got.paginate = paginateEach as GotPaginate;

	got.paginate.all = (async <T, R>(url: string | URL, options?: OptionsWithPagination<T, R>) => Array.fromAsync(paginateEach<T, R>(url, options))) as GotPaginate['all'];

	// For those who like very descriptive names
	got.paginate.each = paginateEach as GotPaginate['each'];

	// Stream API
	got.stream = ((url: string | URL, options?: StreamOptions) =>
		makeRequest(url, options, defaults.options, true)) as GotStream;

	// Shortcuts
	for (const method of aliases) {
		got[method] = ((url: string | URL, options?: Options): GotReturn => got(url, {...options, method})) as GotRequestFunction;

		got.stream[method] = ((url: string | URL, options?: StreamOptions) =>
			makeRequest(url, {...options, method}, defaults.options, true)) as GotStream;
	}

	if (!defaults.mutableDefaults) {
		Object.freeze(defaults.handlers);
		defaults.options.freeze();
	}

	Object.defineProperty(got, 'defaults', {
		value: defaults,
		writable: false,
		configurable: false,
		enumerable: true,
	});

	return got;
};

export default create;

from __future__ import annotations

from typing_extensions import assert_type

from click import progressbar
from click._termui_impl import ProgressBar


def test_length_is_int() -> None:
    with progressbar(length=5) as bar:
        assert_type(bar, ProgressBar[int])
        for i in bar:
            assert_type(i, int)


def it() -> tuple[str, ...]:
    return ("hello", "world")


def test_generic_on_iterable() -> None:
    with progressbar(it()) as bar:
        assert_type(bar, ProgressBar[str])
        for s in bar:
            assert_type(s, str)

import pytest

import click


@pytest.mark.parametrize(
    ("value", "max_length", "expect"),
    [
        pytest.param("", 10, "", id="empty"),
        pytest.param("123 567 90", 10, "123 567 90", id="equal length, no dot"),
        pytest.param("123 567 9. aaaa bbb", 10, "123 567 9.", id="sentence < max"),
        pytest.param("123 567\n\n 9. aaaa bbb", 10, "123 567", id="paragraph < max"),
        pytest.param("123 567 90123.", 10, "123 567...", id="truncate"),
        pytest.param("123 5678 xxxxxx", 10, "123...", id="length includes suffix"),
        pytest.param(
            "token in ~/.netrc ciao ciao",
            20,
            "token in ~/.netrc...",
            id="ignore dot in word",
        ),
    ],
)
@pytest.mark.parametrize(
    "alter",
    [
        pytest.param(None, id=""),
        pytest.param(
            lambda text: "\n\b\n" + "  ".join(text.split(" ")) + "\n", id="no-wrap mark"
        ),
    ],
)
def test_make_default_short_help(value, max_length, alter, expect):
    assert len(expect) <= max_length

    if alter:
        value = alter(value)

    out = click.utils._make_default_short_help(value, max_length)
    assert out == expect

/** Used to map aliases to their real names. */
exports.aliasToReal = {

  // Lodash aliases.
  'each': 'forEach',
  'eachRight': 'forEachRight',
  'entries': 'toPairs',
  'entriesIn': 'toPairsIn',
  'extend': 'assignIn',
  'extendAll': 'assignInAll',
  'extendAllWith': 'assignInAllWith',
  'extendWith': 'assignInWith',
  'first': 'head',

  // Methods that are curried variants of others.
  'conforms': 'conformsTo',
  'matches': 'isMatch',
  'property': 'get',

  // Ramda aliases.
  '__': 'placeholder',
  'F': 'stubFalse',
  'T': 'stubTrue',
  'all': 'every',
  'allPass': 'overEvery',
  'always': 'constant',
  'any': 'some',
  'anyPass': 'overSome',
  'apply': 'spread',
  'assoc': 'set',
  'assocPath': 'set',
  'complement': 'negate',
  'compose': 'flowRight',
  'contains': 'includes',
  'dissoc': 'unset',
  'dissocPath': 'unset',
  'dropLast': 'dropRight',
  'dropLastWhile': 'dropRightWhile',
  'equals': 'isEqual',
  'identical': 'eq',
  'indexBy': 'keyBy',
  'init': 'initial',
  'invertObj': 'invert',
  'juxt': 'over',
  'omitAll': 'omit',
  'nAry': 'ary',
  'path': 'get',
  'pathEq': 'matchesProperty',
  'pathOr': 'getOr',
  'paths': 'at',
  'pickAll': 'pick',
  'pipe': 'flow',
  'pluck': 'map',
  'prop': 'get',
  'propEq': 'matchesProperty',
  'propOr': 'getOr',
  'props': 'at',
  'symmetricDifference': 'xor',
  'symmetricDifferenceBy': 'xorBy',
  'symmetricDifferenceWith': 'xorWith',
  'takeLast': 'takeRight',
  'takeLastWhile': 'takeRightWhile',
  'unapply': 'rest',
  'unnest': 'flatten',
  'useWith': 'overArgs',
  'where': 'conformsTo',
  'whereEq': 'isMatch',
  'zipObj': 'zipObject'
};

/** Used to map ary to method names. */
exports.aryMethod = {
  '1': [
    'assignAll', 'assignInAll', 'attempt', 'castArray', 'ceil', 'create',
    'curry', 'curryRight', 'defaultsAll', 'defaultsDeepAll', 'floor', 'flow',
    'flowRight', 'fromPairs', 'invert', 'iteratee', 'memoize', 'method', 'mergeAll',
    'methodOf', 'mixin', 'nthArg', 'over', 'overEvery', 'overSome','rest', 'reverse',
    'round', 'runInContext', 'spread', 'template', 'trim', 'trimEnd', 'trimStart',
    'uniqueId', 'words', 'zipAll'
  ],
  '2': [
    'add', 'after', 'ary', 'assign', 'assignAllWith', 'assignIn', 'assignInAllWith',
    'at', 'before', 'bind', 'bindAll', 'bindKey', 'chunk', 'cloneDeepWith',
    'cloneWith', 'concat', 'conformsTo', 'countBy', 'curryN', 'curryRightN',
    'debounce', 'defaults', 'defaultsDeep', 'defaultTo', 'delay', 'difference',
    'divide', 'drop', 'dropRight', 'dropRightWhile', 'dropWhile', 'endsWith', 'eq',
    'every', 'filter', 'find', 'findIndex', 'findKey', 'findLast', 'findLastIndex',
    'findLastKey', 'flatMap', 'flatMapDeep', 'flattenDepth', 'forEach',
    'forEachRight', 'forIn', 'forInRight', 'forOwn', 'forOwnRight', 'get',
    'groupBy', 'gt', 'gte', 'has', 'hasIn', 'includes', 'indexOf', 'intersection',
    'invertBy', 'invoke', 'invokeMap', 'isEqual', 'isMatch', 'join', 'keyBy',
    'lastIndexOf', 'lt', 'lte', 'map', 'mapKeys', 'mapValues', 'matchesProperty',
    'maxBy', 'meanBy', 'merge', 'mergeAllWith', 'minBy', 'multiply', 'nth', 'omit',
    'omitBy', 'overArgs', 'pad', 'padEnd', 'padStart', 'parseInt', 'partial',
    'partialRight', 'partition', 'pick', 'pickBy', 'propertyOf', 'pull', 'pullAll',
    'pullAt', 'random', 'range', 'rangeRight', 'rearg', 'reject', 'remove',
    'repeat', 'restFrom', 'result', 'sampleSize', 'some', 'sortBy', 'sortedIndex',
    'sortedIndexOf', 'sortedLastIndex', 'sortedLastIndexOf', 'sortedUniqBy',
    'split', 'spreadFrom', 'startsWith', 'subtract', 'sumBy', 'take', 'takeRight',
    'takeRightWhile', 'takeWhile', 'tap', 'throttle', 'thru', 'times', 'trimChars',
    'trimCharsEnd', 'trimCharsStart', 'truncate', 'union', 'uniqBy', 'uniqWith',
    'unset', 'unzipWith', 'without', 'wrap', 'xor', 'zip', 'zipObject',
    'zipObjectDeep'
  ],
  '3': [
    'assignInWith', 'assignWith', 'clamp', 'differenceBy', 'differenceWith',
    'findFrom', 'findIndexFrom', 'findLastFrom', 'findLastIndexFrom', 'getOr',
    'includesFrom', 'indexOfFrom', 'inRange', 'intersectionBy', 'intersectionWith',
    'invokeArgs', 'invokeArgsMap', 'isEqualWith', 'isMatchWith', 'flatMapDepth',
    'lastIndexOfFrom', 'mergeWith', 'orderBy', 'padChars', 'padCharsEnd',
    'padCharsStart', 'pullAllBy', 'pullAllWith', 'rangeStep', 'rangeStepRight',
    'reduce', 'reduceRight', 'replace', 'set', 'slice', 'sortedIndexBy',
    'sortedLastIndexBy', 'transform', 'unionBy', 'unionWith', 'update', 'xorBy',
    'xorWith', 'zipWith'
  ],
  '4': [
    'fill', 'setWith', 'updateWith'
  ]
};

/** Used to map ary to rearg configs. */
exports.aryRearg = {
  '2': [1, 0],
  '3': [2, 0, 1],
  '4': [3, 2, 0, 1]
};

/** Used to map method names to their iteratee ary. */
exports.iterateeAry = {
  'dropRightWhile': 1,
  'dropWhile': 1,
  'every': 1,
  'filter': 1,
  'find': 1,
  'findFrom': 1,
  'findIndex': 1,
  'findIndexFrom': 1,
  'findKey': 1,
  'findLast': 1,
  'findLastFrom': 1,
  'findLastIndex': 1,
  'findLastIndexFrom': 1,
  'findLastKey': 1,
  'flatMap': 1,
  'flatMapDeep': 1,
  'flatMapDepth': 1,
  'forEach': 1,
  'forEachRight': 1,
  'forIn': 1,
  'forInRight': 1,
  'forOwn': 1,
  'forOwnRight': 1,
  'map': 1,
  'mapKeys': 1,
  'mapValues': 1,
  'partition': 1,
  'reduce': 2,
  'reduceRight': 2,
  'reject': 1,
  'remove': 1,
  'some': 1,
  'takeRightWhile': 1,
  'takeWhile': 1,
  'times': 1,
  'transform': 2
};

/** Used to map method names to iteratee rearg configs. */
exports.iterateeRearg = {
  'mapKeys': [1],
  'reduceRight': [1, 0]
};

/** Used to map method names to rearg configs. */
exports.methodRearg = {
  'assignInAllWith': [1, 0],
  'assignInWith': [1, 2, 0],
  'assignAllWith': [1, 0],
  'assignWith': [1, 2, 0],
  'differenceBy': [1, 2, 0],
  'differenceWith': [1, 2, 0],
  'getOr': [2, 1, 0],
  'intersectionBy': [1, 2, 0],
  'intersectionWith': [1, 2, 0],
  'isEqualWith': [1, 2, 0],
  'isMatchWith': [2, 1, 0],
  'mergeAllWith': [1, 0],
  'mergeWith': [1, 2, 0],
  'padChars': [2, 1, 0],
  'padCharsEnd': [2, 1, 0],
  'padCharsStart': [2, 1, 0],
  'pullAllBy': [2, 1, 0],
  'pullAllWith': [2, 1, 0],
  'rangeStep': [1, 2, 0],
  'rangeStepRight': [1, 2, 0],
  'setWith': [3, 1, 2, 0],
  'sortedIndexBy': [2, 1, 0],
  'sortedLastIndexBy': [2, 1, 0],
  'unionBy': [1, 2, 0],
  'unionWith': [1, 2, 0],
  'updateWith': [3, 1, 2, 0],
  'xorBy': [1, 2, 0],
  'xorWith': [1, 2, 0],
  'zipWith': [1, 2, 0]
};

/** Used to map method names to spread configs. */
exports.methodSpread = {
  'assignAll': { 'start': 0 },
  'assignAllWith': { 'start': 0 },
  'assignInAll': { 'start': 0 },
  'assignInAllWith': { 'start': 0 },
  'defaultsAll': { 'start': 0 },
  'defaultsDeepAll': { 'start': 0 },
  'invokeArgs': { 'start': 2 },
  'invokeArgsMap': { 'start': 2 },
  'mergeAll': { 'start': 0 },
  'mergeAllWith': { 'start': 0 },
  'partial': { 'start': 1 },
  'partialRight': { 'start': 1 },
  'without': { 'start': 1 },
  'zipAll': { 'start': 0 }
};

/** Used to identify methods which mutate arrays or objects. */
exports.mutate = {
  'array': {
    'fill': true,
    'pull': true,
    'pullAll': true,
    'pullAllBy': true,
    'pullAllWith': true,
    'pullAt': true,
    'remove': true,
    'reverse': true
  },
  'object': {
    'assign': true,
    'assignAll': true,
    'assignAllWith': true,
    'assignIn': true,
    'assignInAll': true,
    'assignInAllWith': true,
    'assignInWith': true,
    'assignWith': true,
    'defaults': true,
    'defaultsAll': true,
    'defaultsDeep': true,
    'defaultsDeepAll': true,
    'merge': true,
    'mergeAll': true,
    'mergeAllWith': true,
    'mergeWith': true,
  },
  'set': {
    'set': true,
    'setWith': true,
    'unset': true,
    'update': true,
    'updateWith': true
  }
};

/** Used to map real names to their aliases. */
exports.realToAlias = (function() {
  var hasOwnProperty = Object.prototype.hasOwnProperty,
      object = exports.aliasToReal,
      result = {};

  for (var key in object) {
    var value = object[key];
    if (hasOwnProperty.call(result, value)) {
      result[value].push(key);
    } else {
      result[value] = [key];
    }
  }
  return result;
}());

/** Used to map method names to other names. */
exports.remap = {
  'assignAll': 'assign',
  'assignAllWith': 'assignWith',
  'assignInAll': 'assignIn',
  'assignInAllWith': 'assignInWith',
  'curryN': 'curry',
  'curryRightN': 'curryRight',
  'defaultsAll': 'defaults',
  'defaultsDeepAll': 'defaultsDeep',
  'findFrom': 'find',
  'findIndexFrom': 'findIndex',
  'findLastFrom': 'findLast',
  'findLastIndexFrom': 'findLastIndex',
  'getOr': 'get',
  'includesFrom': 'includes',
  'indexOfFrom': 'indexOf',
  'invokeArgs': 'invoke',
  'invokeArgsMap': 'invokeMap',
  'lastIndexOfFrom': 'lastIndexOf',
  'mergeAll': 'merge',
  'mergeAllWith': 'mergeWith',
  'padChars': 'pad',
  'padCharsEnd': 'padEnd',
  'padCharsStart': 'padStart',
  'propertyOf': 'get',
  'rangeStep': 'range',
  'rangeStepRight': 'rangeRight',
  'restFrom': 'rest',
  'spreadFrom': 'spread',
  'trimChars': 'trim',
  'trimCharsEnd': 'trimEnd',
  'trimCharsStart': 'trimStart',
  'zipAll': 'zip'
};

/** Used to track methods that skip fixing their arity. */
exports.skipFixed = {
  'castArray': true,
  'flow': true,
  'flowRight': true,
  'iteratee': true,
  'mixin': true,
  'rearg': true,
  'runInContext': true
};

/** Used to track methods that skip rearranging arguments. */
exports.skipRearg = {
  'add': true,
  'assign': true,
  'assignIn': true,
  'bind': true,
  'bindKey': true,
  'concat': true,
  'difference': true,
  'divide': true,
  'eq': true,
  'gt': true,
  'gte': true,
  'isEqual': true,
  'lt': true,
  'lte': true,
  'matchesProperty': true,
  'merge': true,
  'multiply': true,
  'overArgs': true,
  'partial': true,
  'partialRight': true,
  'propertyOf': true,
  'random': true,
  'range': true,
  'rangeRight': true,
  'subtract': true,
  'zip': true,
  'zipObject': true,
  'zipObjectDeep': true
};

'use strict'

var after = require('after')
var express = require('../')
  , request = require('supertest');

describe('app', function(){
  describe('.response', function(){
    it('should extend the response prototype', function(done){
      var app = express();

      app.response.shout = function(str){
        this.send(str.toUpperCase());
      };

      app.use(function(req, res){
        res.shout('hey');
      });

      request(app)
      .get('/')
      .expect('HEY', done);
    })

    it('should only extend for the referenced app', function (done) {
      var app1 = express()
      var app2 = express()
      var cb = after(2, done)

      app1.response.shout = function (str) {
        this.send(str.toUpperCase())
      }

      app1.get('/', function (req, res) {
        res.shout('foo')
      })

      app2.get('/', function (req, res) {
        res.shout('foo')
      })

      request(app1)
        .get('/')
        .expect(200, 'FOO', cb)

      request(app2)
        .get('/')
        .expect(500, /(?:not a function|has no method)/, cb)
    })

    it('should inherit to sub apps', function (done) {
      var app1 = express()
      var app2 = express()
      var cb = after(2, done)

      app1.response.shout = function (str) {
        this.send(str.toUpperCase())
      }

      app1.use('/sub', app2)

      app1.get('/', function (req, res) {
        res.shout('foo')
      })

      app2.get('/', function (req, res) {
        res.shout('foo')
      })

      request(app1)
        .get('/')
        .expect(200, 'FOO', cb)

      request(app1)
        .get('/sub')
        .expect(200, 'FOO', cb)
    })

    it('should allow sub app to override', function (done) {
      var app1 = express()
      var app2 = express()
      var cb = after(2, done)

      app1.response.shout = function (str) {
        this.send(str.toUpperCase())
      }

      app2.response.shout = function (str) {
        this.send(str + '!')
      }

      app1.use('/sub', app2)

      app1.get('/', function (req, res) {
        res.shout('foo')
      })

      app2.get('/', function (req, res) {
        res.shout('foo')
      })

      request(app1)
        .get('/')
        .expect(200, 'FOO', cb)

      request(app1)
        .get('/sub')
        .expect(200, 'foo!', cb)
    })

    it('should not pollute parent app', function (done) {
      var app1 = express()
      var app2 = express()
      var cb = after(2, done)

      app1.response.shout = function (str) {
        this.send(str.toUpperCase())
      }

      app2.response.shout = function (str) {
        this.send(str + '!')
      }

      app1.use('/sub', app2)

      app1.get('/sub/foo', function (req, res) {
        res.shout('foo')
      })

      app2.get('/', function (req, res) {
        res.shout('foo')
      })

      request(app1)
        .get('/sub')
        .expect(200, 'foo!', cb)

      request(app1)
        .get('/sub/foo')
        .expect(200, 'FOO', cb)
    })
  })
})

'use strict'

/**
 * Module dependencies.
 */

var https = require('node:https');
var path = require('node:path');
var extname = path.extname;

/**
 * Expose `GithubView`.
 */

module.exports = GithubView;

/**
 * Custom view that fetches and renders
 * remove github templates. You could
 * render templates from a database etc.
 */

function GithubView(name, options){
  this.name = name;
  options = options || {};
  this.engine = options.engines[extname(name)];
  // "root" is the app.set('views') setting, however
  // in your own implementation you could ignore this
  this.path = '/' + options.root + '/master/' + name;
}

/**
 * Render the view.
 */

GithubView.prototype.render = function(options, fn){
  var self = this;
  var opts = {
    host: 'raw.githubusercontent.com',
    port: 443,
    path: this.path,
    method: 'GET'
  };

  https.request(opts, function(res) {
    var buf = '';
    res.setEncoding('utf8');
    res.on('data', function(str){ buf += str });
    res.on('end', function(){
      self.engine(buf, options, fn);
    });
  }).end();
};

import process from 'node:process';
import {Buffer} from 'node:buffer';
import {promisify} from 'node:util';
import stream from 'node:stream';
import {pipeline as streamPipeline} from 'node:stream/promises';
import fs from 'node:fs';
// @ts-expect-error Fails to find slow-stream/index.d.ts
import SlowStream from 'slow-stream';
import getStream from 'get-stream';
import {temporaryFile} from 'tempy';
import is from '@sindresorhus/is';
import test, {type ExecutionContext} from 'ava';
import type {Handler} from 'express';
import {pEvent} from 'p-event';
import {chunk, chunkFromAsync} from 'chunk-data';
import type {Progress} from '../source/index.js';
import withServer from './helpers/with-server.js';

const checkEvents = (t: ExecutionContext, events: Progress[], bodySize?: number) => {
	t.true(events.length >= 2);

	let lastEvent = events.shift()!;

	if (!is.number(bodySize)) {
		t.is(lastEvent.percent, 0);
	}

	for (const [index, event] of events.entries()) {
		const isLastEvent = index === events.length - 1;

		if (is.number(bodySize)) {
			t.is(event.percent, event.transferred / bodySize);
			t.true(event.percent > lastEvent.percent);
			t.true(event.transferred > lastEvent.transferred);
		} else if (isLastEvent) {
			t.is(event.percent, 1);
			t.is(event.transferred, lastEvent.transferred);
			t.is(event.total, event.transferred);
		} else {
			t.is(event.percent, 0);
			t.true(event.transferred > lastEvent.transferred);
		}

		lastEvent = event;
	}
};

const file = Buffer.alloc(1024 * 1024 * 2);

const downloadEndpoint: Handler = (_request, response) => {
	response.setHeader('content-length', file.length);

	(async () => {
		try {
			await streamPipeline(
				stream.Readable.from(file),
				new SlowStream({maxWriteInterval: 50}),
				response,
			);
		} catch {}

		response.end();
	})();
};

const noTotalEndpoint: Handler = (_request, response) => {
	response.write('hello');
	response.end();
};

const uploadEndpoint: Handler = (request, response) => {
	(async () => {
		try {
			await streamPipeline(
				request,
				new SlowStream({maxWriteInterval: 100}),
			);
		} catch {}

		response.end();
	})();
};

test('download progress', withServer, async (t, server, got) => {
	server.get('/', downloadEndpoint);

	const events: Progress[] = [];

	const {body} = await got({responseType: 'buffer'})
		.on('downloadProgress', event => {
			events.push(event);
		});

	checkEvents(t, events, body.length);
});

test('download progress - missing total size', withServer, async (t, server, got) => {
	server.get('/', noTotalEndpoint);

	const events: Progress[] = [];

	await got('').on('downloadProgress', (event: Progress) => {
		events.push(event);
	});

	t.is(events[0]?.total, undefined);
	checkEvents(t, events);
});

test('download progress - stream', withServer, async (t, server, got) => {
	server.get('/', downloadEndpoint);

	const events: Progress[] = [];

	const stream = got.stream({responseType: 'buffer'})
		.on('downloadProgress', event => {
			events.push(event);
		});

	await getStream(stream);

	checkEvents(t, events, file.length);
});

test('upload progress - file', withServer, async (t, server, got) => {
	server.post('/', uploadEndpoint);

	const events: Progress[] = [];

	await got.post({body: file}).on('uploadProgress', (event: Progress) => {
		events.push(event);
	});

	checkEvents(t, events, file.length);
});

test('upload progress - file stream', withServer, async (t, server, got) => {
	server.post('/', uploadEndpoint);

	const path = temporaryFile();
	fs.writeFileSync(path, file);

	const {size} = await promisify(fs.stat)(path);

	const events: Progress[] = [];

	await got.post({
		body: fs.createReadStream(path),
		headers: {
			'content-length': size.toString(),
		},
	})
		.on('uploadProgress', (event: Progress) => {
			events.push(event);
		});

	checkEvents(t, events, file.length);
});

test('upload progress - form data', withServer, async (t, server, got) => {
	server.post('/', uploadEndpoint);

	const events: Progress[] = [];

	const body = new globalThis.FormData();
	body.set('key', 'value');
	body.set('file', new File([file], 'file'));

	await got.post({body}).on('uploadProgress', (event: Progress) => {
		events.push(event);
	});

	checkEvents(t, events);
});

test('upload progress - json', withServer, async (t, server, got) => {
	server.post('/', uploadEndpoint);

	const body = JSON.stringify({key: 'value'});
	const size = Buffer.byteLength(body);
	const events: Progress[] = [];

	await got.post({body}).on('uploadProgress', (event: Progress) => {
		events.push(event);
	});

	checkEvents(t, events, size);
});

test('upload progress - measures bytes correctly for non-UTF-8 encoded strings', withServer, async (t, server, got) => {
	server.post('/', uploadEndpoint);

	// String with emoji - 'Hello 👋' is 10 bytes in UTF-8, but 16 bytes in UTF-16LE
	const text = 'Hello 👋';
	const utf8Size = Buffer.from(text, 'utf8').byteLength; // 10 bytes
	const utf16Size = Buffer.from(text, 'utf16le').byteLength; // 16 bytes

	t.is(utf8Size, 10);
	t.is(utf16Size, 16);

	const events: Progress[] = [];

	// Upload as UTF-8 (default)
	await got.post({body: text}).on('uploadProgress', (event: Progress) => {
		events.push(event);
	});

	// Verify the progress measures UTF-8 bytes correctly
	const finalEvent = events.at(-1)!;
	t.is(finalEvent.transferred, utf8Size);
	t.is(finalEvent.total, utf8Size);
});

test('upload progress - stream with known body size', withServer, async (t, server, got) => {
	server.post('/', uploadEndpoint);

	const events: Progress[] = [];
	const options = {
		headers: {'content-length': file.length.toString()},
	};

	const request = got.stream.post(options)
		.on('uploadProgress', event => {
			events.push(event);
		});

	await streamPipeline(stream.Readable.from(file), request);
	await getStream(request);

	checkEvents(t, events, file.length);
});

test('upload progress - stream with unknown body size', withServer, async (t, server, got) => {
	server.post('/', uploadEndpoint);

	const events: Progress[] = [];

	const request = got.stream.post('')
		.on('uploadProgress', event => {
			events.push(event);
		});

	await streamPipeline(stream.Readable.from(file), request);
	await getStream(request);

	t.is(events[0]?.total, undefined);
	checkEvents(t, events);
});

test('upload progress - no body', withServer, async (t, server, got) => {
	server.post('/', uploadEndpoint);

	const events: Progress[] = [];

	await got.post('').on('uploadProgress', (event: Progress) => {
		events.push(event);
	});

	t.deepEqual(events, [
		{
			percent: 0,
			transferred: 0,
			total: undefined,
		},
		{
			percent: 1,
			transferred: 0,
			total: 0,
		},
	]);
});

test('upload progress - no events when immediately removed listener', withServer, async (t, server, got) => {
	server.post('/', uploadEndpoint);

	const events: Progress[] = [];

	const listener = (event: Progress) => {
		events.push(event);
	};

	const promise = got.post('')
		.on('uploadProgress', listener)
		.off('uploadProgress', listener);

	await promise;

	t.is(events.length, 0);
});

test('upload progress - one event when removed listener', withServer, async (t, server, got) => {
	server.post('/', uploadEndpoint);

	const events: Progress[] = [];

	const promise = got.post('');

	const listener = (event: Progress) => {
		events.push(event);
		void promise.off('uploadProgress', listener);
	};

	void promise.on('uploadProgress', listener);

	await promise;

	t.deepEqual(events, [
		{
			percent: 0,
			transferred: 0,
			total: undefined,
		},
	]);
});

test('does not emit uploadProgress after cancelation', withServer, async (t, server, got) => {
	server.post('/', () => {});

	const stream = got.stream.post();

	stream.once('uploadProgress', () => { // 0%
		stream.once('uploadProgress', () => { // 'foo'
			stream.write('bar');

			process.nextTick(() => {
				process.nextTick(() => {
					stream.on('uploadProgress', () => {
						t.fail('Emitted uploadProgress after cancelation');
					});

					stream.destroy();
				});
			});
		});
	});

	stream.write('foo');

	await pEvent(stream, 'close');

	t.pass();
});

test('upload progress - chunk generator with buffer', withServer, async (t, server, got) => {
	server.post('/', uploadEndpoint);

	const events: Progress[] = [];

	await got.post({
		body: chunk(file, 65_536),
		headers: {
			'content-length': file.length.toString(),
		},
	})
		.on('uploadProgress', (event: Progress) => {
			events.push(event);
		});

	checkEvents(t, events, file.length);

	// Ensure we got more than just 0% and 100%
	t.true(events.length > 2, `Expected more than 2 events with chunk, got ${events.length}`);
});

test('upload progress - chunkFromAsync async generator with stream', withServer, async (t, server, got) => {
	server.post('/', uploadEndpoint);

	const events: Progress[] = [];

	await got.post({
		body: chunkFromAsync(stream.Readable.from([file]), 65_536),
		headers: {
			'content-length': file.length.toString(),
		},
	})
		.on('uploadProgress', (event: Progress) => {
			events.push(event);
		});

	checkEvents(t, events, file.length);

	// Ensure we got more than just 0% and 100%
	t.true(events.length > 2, `Expected more than 2 events with chunkFromAsync, got ${events.length}`);
});

test('upload progress - buffer body', withServer, async (t, server, got) => {
	server.post('/', uploadEndpoint);

	const events: Progress[] = [];
	const body = Buffer.alloc(1024 * 256); // 256 KB

	await got.post({
		body,
		headers: {'content-length': body.byteLength.toString()},
	}).on('uploadProgress', (event: Progress) => {
		events.push(event);
	});

	checkEvents(t, events, body.byteLength);

	// Ensure we got more than just 0% and 100%
	t.true(events.length > 2, `Expected more than 2 events with buffer body, got ${events.length}`);
});

test('upload progress - typed array body', withServer, async (t, server, got) => {
	server.post('/', uploadEndpoint);

	const events: Progress[] = [];
	const body = new Uint8Array(1024 * 256); // 256 KB

	await got.post({
		body,
		headers: {'content-length': body.byteLength.toString()},
	}).on('uploadProgress', (event: Progress) => {
		events.push(event);
	});

	checkEvents(t, events, body.byteLength);

	// Ensure we got more than just 0% and 100%
	t.true(events.length > 2, `Expected more than 2 events with typed array body, got ${events.length}`);
});

test('upload progress - small json option', withServer, async (t, server, got) => {
	server.post('/', uploadEndpoint);

	const events: Progress[] = [];
	const payload = {key: 'value'};
	const size = Buffer.byteLength(JSON.stringify(payload));

	await got.post({json: payload}).on('uploadProgress', (event: Progress) => {
		events.push(event);
	});

	checkEvents(t, events, size);
});

test('upload progress - json option', withServer, async (t, server, got) => {
	server.post('/', uploadEndpoint);

	const events: Progress[] = [];
	const payload = {key: '.'.repeat(1e6)};
	const size = Buffer.byteLength(JSON.stringify(payload));

	await got.post({json: payload}).on('uploadProgress', (event: Progress) => {
		events.push(event);
	});

	checkEvents(t, events, size);

	// Ensure we got more than just 0% and 100%
	t.true(events.length > 2, `Expected more than 2 events with json option, got ${events.length}`);
});

test('upload progress - form option', withServer, async (t, server, got) => {
	server.post('/', uploadEndpoint);

	const events: Progress[] = [];
	const payload = {key: '.'.repeat(1e6)};
	const size = Buffer.byteLength(new URLSearchParams(payload).toString());

	await got.post({form: payload}).on('uploadProgress', (event: Progress) => {
		events.push(event);
	});

	checkEvents(t, events, size);

	// Ensure we got more than just 0% and 100%
	t.true(events.length > 2, `Expected more than 2 events with form option, got ${events.length}`);
});

<a id="top"></a>
# Migrating from v2 to v3

v3 is the next major version of Catch2 and brings three significant changes:
 * Catch2 is now split into multiple headers
 * Catch2 is now compiled as a static library
 * C++14 is the minimum required C++ version

There are many reasons why we decided to go from the old single-header
distribution model to a more standard library distribution model. The
big one is compile-time performance, but moving over to a split header
distribution model also improves the future maintainability and
extendability of the codebase. For example v3 adds a new kind of matchers
without impacting the compilation times of users that do not use matchers
in their tests. The new model is also more friendly towards package
managers, such as vcpkg and Conan.

The result of this move is a significant improvement in compilation
times, e.g. the inclusion overhead of Catch2 in the common case has been
reduced by roughly 80%. The improved ease of maintenance also led to
various runtime performance improvements and the introduction of new features.
For details, look at [the release notes of 3.0.1](release-notes.md#301).

_Note that we still provide one header + one translation unit (TU)
distribution but do not consider it the primarily supported option. You
should also expect that the compilation times will be worse if you use
this option._


## How to migrate projects from v2 to v3

To migrate to v3, there are two basic approaches to do so.

1. Use `catch_amalgamated.hpp` and `catch_amalgamated.cpp`.
2. Build Catch2 as a proper (static) library, and move to piecewise headers

Doing 1 means downloading the [amalgamated header](/extras/catch_amalgamated.hpp)
and the [amalgamated sources](/extras/catch_amalgamated.cpp) from `extras`,
dropping them into your test project, and rewriting your includes from
`<catch2/catch.hpp>` to `"catch_amalgamated.hpp"` (or something similar,
based on how you set up your paths).

The disadvantage of using this approach are increased compilation times,
at least compared to the second approach, but it does let you avoid
dealing with consuming libraries in your build system of choice.


However, we recommend doing 2, and taking extra time to migrate to v3
properly. This lets you reap the benefits of significantly improved
compilation times in the v3 version. The basic steps to do so are:

1. Change your CMakeLists.txt to link against `Catch2WithMain` target if
you use Catch2's default main. (If you do not, keep linking against
the `Catch2` target.). If you use pkg-config, change `pkg-config catch2` to
`pkg-config catch2-with-main`.
2. Delete TU with `CATCH_CONFIG_RUNNER` or `CATCH_CONFIG_MAIN` defined,
as it is no longer needed.
3. Change `#include <catch2/catch.hpp>` to `#include <catch2/catch_all.hpp>`
4. Check that everything compiles. You might have to modify namespaces,
or perform some other changes (see the
[Things that can break during porting](#things-that-can-break-during-porting)
section for the most common things).
5. Start migrating your test TUs from including `<catch2/catch_all.hpp>`
to piecemeal includes. You will likely want to start by including
`<catch2/catch_test_macros.hpp>`, and then go from there. (see
[other notes](#other-notes) for further ideas)

## Other notes

* The main test include is now `<catch2/catch_test_macros.hpp>`

* Big "subparts" like Matchers, or Generators, have their own folder, and
also their own "big header", so if you just want to include all matchers,
you can include `<catch2/matchers/catch_matchers_all.hpp>`,
or `<catch2/generators/catch_generators_all.hpp>`


## Things that can break during porting

* The namespaces of Matchers were flattened and cleaned up.

Matchers are no longer declared deep within an internal namespace and
then brought up into `Catch` namespace. All Matchers now live in the
`Catch::Matchers` namespace.

* The `Contains` string matcher was renamed to `ContainsSubstring`.

* The reporter interfaces changed in a breaking manner.

If you are using a custom reporter or listener, you will likely need to
modify them to conform to the new interfaces. Unlike before in v2,
the [interfaces](reporters.md#top) and the [events](reporter-events.md#top)
are now documented.


---

[Home](Readme.md#top)

from urllib import parse as urlparse

import click


def validate_count(ctx, param, value):
    if value < 0 or value % 2 != 0:
        raise click.BadParameter("Should be a positive, even integer.")
    return value


class URL(click.ParamType[urlparse.ParseResult]):
    name = "url"

    def convert(self, value, param, ctx) -> urlparse.ParseResult:
        if not isinstance(value, tuple):
            value = urlparse.urlparse(value)
            if value.scheme not in ("http", "https"):
                self.fail(
                    f"invalid URL scheme ({value.scheme}). Only HTTP URLs are allowed",
                    param,
                    ctx,
                )
        return value


@click.command()
@click.option(
    "--count", default=2, callback=validate_count, help="A positive even number."
)
@click.option("--foo", help="A mysterious parameter.")
@click.option("--url", help="A URL", type=URL())
@click.version_option()
def cli(count, foo, url):
    """Validation.

    This example validates parameters in different ways.  It does it
    through callbacks, through a custom type as well as by validating
    manually in the function.
    """
    if foo is not None and foo != "wat":
        raise click.BadParameter(
            'If a value is provided it needs to be the value "wat".',
            param_hint=["--foo"],
        )
    click.echo(f"count: {count}")
    click.echo(f"foo: {foo}")
    click.echo(f"url: {url!r}")

name: CI Browsers

on:
  push:
    branches: [ main ]
  pull_request:
    # Run on every PR, regardless of branch
    branches: [ '*' ]
  workflow_dispatch:

jobs:
  test-docs:
    name: Modern Browsers Test
    runs-on: ubuntu-latest

    steps:
      - uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4.3.1

      - name: Install Node
        uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4.4.0
        with:
          node-version: '24'

      - name: Install dependencies
        run: |
          npm install
          npx playwright install --with-deps
          npm install -D @playwright/test@latest

      - name: Build project
        run: npm run build

      - name: Start server
        run: |
          npx http-server -p 9001 &
          sleep 2

      - name: Run Playwright tests
        run: npx playwright test

import {Buffer} from 'node:buffer';
import test from 'ava';
import type {Handler} from 'express';
import getStream from 'get-stream';
import {HTTPError, ParseError} from '../source/index.js';
import withServer from './helpers/with-server.js';

const dog = {data: 'dog'};
const jsonResponse = JSON.stringify(dog);

const defaultHandler: Handler = (_request, response) => {
	response.end(jsonResponse);
};

test('`options.resolveBodyOnly` works', withServer, async (t, server, got) => {
	server.get('/', defaultHandler);

	t.deepEqual(await got<Record<string, unknown>>({responseType: 'json', resolveBodyOnly: true}), dog);
});

test('`options.resolveBodyOnly` combined with `options.throwHttpErrors`', withServer, async (t, server, got) => {
	server.get('/', (_request, response) => {
		response.statusCode = 404;
		response.end('/');
	});

	t.is(await got({resolveBodyOnly: true, throwHttpErrors: false}), '/');
});

test('JSON response', withServer, async (t, server, got) => {
	server.get('/', defaultHandler);

	t.deepEqual((await got({responseType: 'json'})).body, dog);
});

test('Uint8Array response', withServer, async (t, server, got) => {
	server.get('/', defaultHandler);

	const {body} = await got({responseType: 'buffer'});
	t.deepEqual(body, new TextEncoder().encode(jsonResponse));
	t.true(body instanceof Uint8Array);
	t.false(Buffer.isBuffer(body));
});

test('rawBody is compatible with web APIs', withServer, async (t, server, got) => {
	server.get('/', defaultHandler);

	const {rawBody} = await got({responseType: 'text'});
	t.true(rawBody.buffer instanceof ArrayBuffer);
	t.is(await new Blob([rawBody]).text(), jsonResponse);
	t.is(await new Response(rawBody).text(), jsonResponse);
});

test('Text response', withServer, async (t, server, got) => {
	server.get('/', defaultHandler);

	t.is((await got({responseType: 'text'})).body, jsonResponse);
});

test('Text response #2', withServer, async (t, server, got) => {
	server.get('/', defaultHandler);

	t.is((await got({responseType: undefined})).body, jsonResponse);
});

test('Text response preserves UTF-8 BOM', withServer, async (t, server, got) => {
	server.get('/', (_request, response) => {
		response.end(Buffer.from([0xEF, 0xBB, 0xBF, ...Buffer.from('hello')]));
	});

	t.is((await got({responseType: 'text'})).body, '\uFEFFhello');
});

test('Text response shortcut strips UTF-8 BOM', withServer, async (t, server, got) => {
	server.get('/', (_request, response) => {
		response.end(Buffer.from([0xEF, 0xBB, 0xBF, ...Buffer.from('hello')]));
	});

	t.is(await got('').text(), 'hello');
});

test('JSON response - promise.json()', withServer, async (t, server, got) => {
	server.get('/', defaultHandler);

	t.deepEqual(await got('').json(), dog);
});

test('Uint8Array response - promise.buffer()', withServer, async (t, server, got) => {
	server.get('/', defaultHandler);

	const body = await got('').buffer();
	t.deepEqual(body, new TextEncoder().encode(jsonResponse));
	t.true(body instanceof Uint8Array);
	t.false(Buffer.isBuffer(body));
});

test('Text response - promise.text()', withServer, async (t, server, got) => {
	server.get('/', defaultHandler);

	t.is(await got('').text(), jsonResponse);
});

test('Text response - promise.json().text()', withServer, async (t, server, got) => {
	server.get('/', defaultHandler);

	t.is(await got('').json().text(), jsonResponse);
});

test('works if promise has been already resolved', withServer, async (t, server, got) => {
	server.get('/', defaultHandler);

	const promise = got('').text();
	t.is(await promise, jsonResponse);
	t.deepEqual(await promise.json(), dog);
});

test('throws an error on invalid response type', withServer, async (t, server, got) => {
	server.get('/', defaultHandler);

	// @ts-expect-error Error tests
	const error = await t.throwsAsync<ParseError>(got({responseType: 'invalid'}));
	t.is(error?.message, 'Invalid `responseType` option: invalid');
});

test('wraps parsing errors', withServer, async (t, server, got) => {
	server.get('/', (_request, response) => {
		response.end('/');
	});

	const error = await t.throwsAsync<ParseError>(got({responseType: 'json'}), {instanceOf: ParseError});
	t.true(error?.message.includes((error.options.url as URL).hostname));
	t.is((error?.options.url as URL).pathname, '/');
	t.is(error?.code, 'ERR_BODY_PARSE_FAILURE');
});

test('credentials are stripped from ParseError message URL', withServer, async (t, server, got) => {
	server.get('/', (_request, response) => {
		response.end('/');
	});

	const url = new URL(server.url);
	url.username = 'user';
	url.password = 'secret';

	const error = await t.throwsAsync<ParseError>(got(url, {responseType: 'json'}), {instanceOf: ParseError});
	t.false(error?.message.includes('user'));
	t.false(error?.message.includes('secret'));
	t.regex(error?.message ?? '', /in "http:\/\/localhost:\d+\/"$/v);
});

test('JSON response with UTF-8 BOM throws ParseError', withServer, async (t, server, got) => {
	server.get('/', (_request, response) => {
		response.end(Buffer.from([0xEF, 0xBB, 0xBF, ...Buffer.from(jsonResponse)]));
	});

	await t.throwsAsync(got({responseType: 'json'}), {instanceOf: ParseError});
});

test('parses non-200 responses', withServer, async (t, server, got) => {
	server.get('/', (_request, response) => {
		response.statusCode = 500;
		response.end(jsonResponse);
	});

	const error = await t.throwsAsync<HTTPError>(got({responseType: 'json', retry: {limit: 0}}), {instanceOf: HTTPError});
	t.deepEqual(error?.response.body, dog);
});

test('ignores errors on invalid non-200 responses', withServer, async (t, server, got) => {
	server.get('/', (_request, response) => {
		response.statusCode = 500;
		response.end('Internal error');
	});

	const error = await t.throwsAsync<HTTPError>(got({responseType: 'json', retry: {limit: 0}}), {
		instanceOf: HTTPError,
		message: /^Request failed with status code 500 \(Internal Server Error\): GET http:\/\/localhost:\d+\/$/v,
	});

	t.is(error?.response.body, 'Internal error');
	t.is((error?.options.url as URL).pathname, '/');
});

test('parse errors have `response` property', withServer, async (t, server, got) => {
	server.get('/', (_request, response) => {
		response.end('/');
	});

	const error = await t.throwsAsync<ParseError>(got({responseType: 'json'}), {instanceOf: ParseError});

	t.is(error?.response.statusCode, 200);
	t.is(error?.response.body, '/');
	t.is(error?.code, 'ERR_BODY_PARSE_FAILURE');
});

test('sets correct headers', withServer, async (t, server, got) => {
	server.post('/', (request, response) => {
		response.end(JSON.stringify(request.headers));
	});

	const {body: headers} = await got.post<Record<string, string>>({responseType: 'json', json: {}});
	t.is(headers['content-type'], 'application/json');
	t.is(headers.accept, 'application/json');
});

test('doesn\'t throw on 204 No Content', withServer, async (t, server, got) => {
	server.get('/', (_request, response) => {
		response.statusCode = 204;
		response.end();
	});

	const body = await got('').json();
	t.is(body, '');
});

test('doesn\'t throw on empty bodies', withServer, async (t, server, got) => {
	server.get('/', (_request, response) => {
		response.statusCode = 200;
		response.end();
	});

	const body = await got('').json();
	t.is(body, '');
});

test('.buffer() returns binary content', withServer, async (t, server, got) => {
	const body = Buffer.from('89504E470D0A1A0A0000000D49484452', 'hex');

	server.get('/', (_request, response) => {
		response.end(body);
	});

	const buffer = await got('').buffer();
	t.is(Buffer.compare(buffer, body), 0);
});

test('shortcuts throw ParseErrors', withServer, async (t, server, got) => {
	server.get('/', (_request, response) => {
		response.end('not a json');
	});

	await t.throwsAsync(got('').json(), {
		instanceOf: ParseError,
		message: /^Unexpected token/v,
		code: 'ERR_BODY_PARSE_FAILURE',
	});
});

test('shortcuts result properly when retrying in afterResponse', withServer, async (t, server, got) => {
	const nasty = JSON.stringify({hello: 'nasty'});
	const proper = JSON.stringify({hello: 'world'});

	server.get('/', (request, response) => {
		if (request.headers.token === 'unicorn') {
			response.end(proper);
		} else {
			response.statusCode = 401;
			response.end(nasty);
		}
	});

	const promise = got({
		hooks: {
			afterResponse: [
				(response, retryWithMergedOptions) => {
					if (response.statusCode === 401) {
						return retryWithMergedOptions({
							headers: {
								token: 'unicorn',
							},
						});
					}

					return response;
				},
			],
		},
	});

	const json = await promise.json<{hello: string}>();
	const text = await promise.text();
	const buffer = await promise.buffer();

	t.is(json.hello, 'world');
	t.is(text, proper);
	t.is(Buffer.from(buffer).compare(Buffer.from(proper)), 0);
});

test('responseType is optional when using template', withServer, async (t, server, got) => {
	const data = {hello: 'world'};

	server.post('/', async (request, response) => {
		response.end(await getStream(request));
	});

	const jsonClient = got.extend({responseType: 'json'});
	const {body} = await jsonClient.post<typeof data>('', {json: data});

	t.deepEqual(body, data);
});

test('JSON response custom parser', withServer, async (t, server, got) => {
	server.get('/', defaultHandler);

	t.deepEqual((await got({
		responseType: 'json',
		parseJson: text => ({...JSON.parse(text), custom: 'parser'}),
	})).body, {...dog, custom: 'parser'});
});

test.serial('incrementally decodes UTF-8 text response while downloading', withServer, async (t, server, got) => {
	if (globalThis.TextDecoder === undefined) {
		t.pass();
		return;
	}

	const originalDecode = globalThis.TextDecoder.prototype.decode;
	let responseEnded = false;
	let streamDecodeCallCount = 0;
	let decodedBeforeResponseEnded = false;

	globalThis.TextDecoder.prototype.decode = function (input?: BufferSource, options?: TextDecodeOptions): string {
		if (options?.stream) {
			streamDecodeCallCount++;
			if (!responseEnded) {
				decodedBeforeResponseEnded = true;
			}
		}

		return originalDecode.call(this, input, options);
	};

	server.get('/', (_request, response) => {
		response.write('hello ');

		setTimeout(() => {
			responseEnded = true;
			response.end('world');
		}, 25);
	});

	try {
		const {body} = await got({responseType: 'text'});
		t.is(body, 'hello world');
		t.true(streamDecodeCallCount > 0);
		t.true(decodedBeforeResponseEnded);
	} finally {
		globalThis.TextDecoder.prototype.decode = originalDecode;
	}
});

test.serial('incrementally decodes UTF-8 JSON response while downloading', withServer, async (t, server, got) => {
	if (globalThis.TextDecoder === undefined) {
		t.pass();
		return;
	}

	const originalDecode = globalThis.TextDecoder.prototype.decode;
	let responseEnded = false;
	let streamDecodeCallCount = 0;
	let decodedBeforeResponseEnded = false;

	globalThis.TextDecoder.prototype.decode = function (input?: BufferSource, options?: TextDecodeOptions): string {
		if (options?.stream) {
			streamDecodeCallCount++;
			if (!responseEnded) {
				decodedBeforeResponseEnded = true;
			}
		}

		return originalDecode.call(this, input, options);
	};

	server.get('/', (_request, response) => {
		response.write('{"hello":"');

		setTimeout(() => {
			responseEnded = true;
			response.end('world"}');
		}, 25);
	});

	try {
		const {body} = await got<{hello: string}>({responseType: 'json'});
		t.deepEqual(body, {hello: 'world'});
		t.true(streamDecodeCallCount > 0);
		t.true(decodedBeforeResponseEnded);
	} finally {
		globalThis.TextDecoder.prototype.decode = originalDecode;
	}
});

test.serial('falls back to buffered decode when incremental decode throws', withServer, async (t, server, got) => {
	if (globalThis.TextDecoder === undefined) {
		t.pass();
		return;
	}

	const originalDecode = globalThis.TextDecoder.prototype.decode;
	const payload = {hello: 'world'};
	let thrown = false;

	globalThis.TextDecoder.prototype.decode = function (input?: BufferSource, options?: TextDecodeOptions): string {
		if (!thrown && options?.stream) {
			thrown = true;
			throw new TypeError('Injected decode failure');
		}

		return originalDecode.call(this, input, options);
	};

	server.get('/', (_request, response) => {
		response.end(JSON.stringify(payload));
	});

	try {
		const {body} = await got<typeof payload>({responseType: 'json'});
		t.true(thrown);
		t.deepEqual(body, payload);
	} finally {
		globalThis.TextDecoder.prototype.decode = originalDecode;
	}
});

test.serial('falls back to buffered decode when incremental decoder final flush throws', withServer, async (t, server, got) => {
	if (globalThis.TextDecoder === undefined) {
		t.pass();
		return;
	}

	const originalDecode = globalThis.TextDecoder.prototype.decode;
	const payload = {hello: 'world'};
	let thrown = false;

	globalThis.TextDecoder.prototype.decode = function (input?: BufferSource, options?: TextDecodeOptions): string {
		if (!thrown && options === undefined) {
			thrown = true;
			throw new TypeError('Injected final flush decode failure');
		}

		return originalDecode.call(this, input, options);
	};

	server.get('/', (_request, response) => {
		response.end(JSON.stringify(payload));
	});

	try {
		const {body} = await got<typeof payload>({responseType: 'json'});
		t.true(thrown);
		t.deepEqual(body, payload);
	} finally {
		globalThis.TextDecoder.prototype.decode = originalDecode;
	}
});

test.serial('does not incrementally decode for non-UTF-8 encoding', withServer, async (t, server, got) => {
	if (globalThis.TextDecoder === undefined) {
		t.pass();
		return;
	}

	const originalDecode = globalThis.TextDecoder.prototype.decode;
	const payload = 'a'.repeat(1024);
	let streamDecodeCallCount = 0;

	globalThis.TextDecoder.prototype.decode = function (input?: BufferSource, options?: TextDecodeOptions): string {
		if (options?.stream) {
			streamDecodeCallCount++;
		}

		return originalDecode.call(this, input, options);
	};

	server.get('/', (_request, response) => {
		response.end(payload);
	});

	try {
		const {body} = await got({
			responseType: 'text',
			encoding: 'base64',
		});

		t.is(body, Buffer.from(payload).toString('base64'));
		t.is(streamDecodeCallCount, 0);
	} finally {
		globalThis.TextDecoder.prototype.decode = originalDecode;
	}
});

test.serial('incrementally decodes for case-insensitive UTF-8 encoding names', withServer, async (t, server, got) => {
	if (globalThis.TextDecoder === undefined) {
		t.pass();
		return;
	}

	const originalDecode = globalThis.TextDecoder.prototype.decode;
	const payload = 'hello world';
	const encoding = Buffer.from([85, 84, 70, 45, 56]).toString() as BufferEncoding;
	let streamDecodeCallCount = 0;

	globalThis.TextDecoder.prototype.decode = function (input?: BufferSource, options?: TextDecodeOptions): string {
		if (options?.stream) {
			streamDecodeCallCount++;
		}

		return originalDecode.call(this, input, options);
	};

	server.get('/', (_request, response) => {
		response.end(payload);
	});

	try {
		const encodingWithoutHyphen = Buffer.from([85, 84, 70, 56]).toString() as BufferEncoding;
		const responses = await Promise.all([
			got({
				responseType: 'text',
				encoding,
			}),
			got({
				responseType: 'text',
				encoding: encodingWithoutHyphen,
			}),
		]);

		for (const response of responses) {
			t.is(response.body, payload);
		}

		t.true(streamDecodeCallCount > 0);
	} finally {
		globalThis.TextDecoder.prototype.decode = originalDecode;
	}
});

test.serial('does not incrementally decode in stream mode', withServer, async (t, server, got) => {
	if (globalThis.TextDecoder === undefined) {
		t.pass();
		return;
	}

	const originalDecode = globalThis.TextDecoder.prototype.decode;
	let streamDecodeCallCount = 0;

	globalThis.TextDecoder.prototype.decode = function (input?: BufferSource, options?: TextDecodeOptions): string {
		if (options?.stream) {
			streamDecodeCallCount++;
		}

		return originalDecode.call(this, input, options);
	};

	server.get('/', (_request, response) => {
		response.end('hello');
	});

	try {
		await new Promise<void>((resolve, reject) => {
			const streamRequest = got.stream({responseType: 'text'});
			streamRequest.on('error', reject);
			streamRequest.on('end', resolve);
			streamRequest.resume();
		});

		t.is(streamDecodeCallCount, 0);
	} finally {
		globalThis.TextDecoder.prototype.decode = originalDecode;
	}
});

export default function isUnixSocketUrl(url: URL) {
	return url.protocol === 'unix:' || url.hostname === 'unix';
}

/**
Extract the socket path from a UNIX socket URL.

@example
```
getUnixSocketPath(new URL('http://unix/foo:/path'));
//=> '/foo'

getUnixSocketPath(new URL('unix:/foo:/path'));
//=> '/foo'

getUnixSocketPath(new URL('http://example.com'));
//=> undefined
```
*/
export function getUnixSocketPath(url: URL): string | undefined {
	if (!isUnixSocketUrl(url)) {
		return undefined;
	}

	return /^(?<socketPath>[^:]+):/v.exec(`${url.pathname}${url.search}`)?.groups?.socketPath;
}

'use strict'

module.exports = User;

// faux model

function User(name, age, species) {
  this.name = name;
  this.age = age;
  this.species = species;
}

User.all = function(fn){
  // process.nextTick makes sure this function API
  // behaves in an asynchronous manner, like if it
  // was a real DB query to read all users.
  process.nextTick(function(){
    fn(null, users);
  });
};

User.count = function(fn){
  process.nextTick(function(){
    fn(null, users.length);
  });
};

// faux database

var users = [];

users.push(new User('Tobi', 2, 'ferret'));
users.push(new User('Loki', 1, 'ferret'));
users.push(new User('Jane', 6, 'ferret'));
users.push(new User('Luna', 1, 'cat'));
users.push(new User('Manny', 1, 'cat'));

from jinja2 import Environment

env = Environment(extensions=["jinja2.ext.i18n"])
env.globals["gettext"] = {"Hello %(user)s!": "Hallo %(user)s!"}.__getitem__
env.globals["ngettext"] = lambda s, p, n: {
    "%(count)s user": "%(count)d Benutzer",
    "%(count)s users": "%(count)d Benutzer",
}[s if n == 1 else p]
print(
    env.from_string(
        """\
{% trans %}Hello {{ user }}!{% endtrans %}
{% trans count=users|count -%}
{{ count }} user{% pluralize %}{{ count }} users
{% endtrans %}
"""
    ).render(user="someone", users=[1, 2, 3])
)

[> Back to homepage](../readme.md#documentation)

## Retry API

**Note:**
> If you're looking for retry implementation using streams, check out the [Retry Stream API](3-streams.md#retry).

**Tip:**
> You can trigger a retry by throwing the [`RetryError`](8-errors.md#retryerror) in any hook.

**Tip:**
> The `afterResponse` hook exposes a dedicated function to retry with merged options. [Read more](9-hooks.md#afterresponse).

### `retry`

**Type: `object`**\
**Default:**

```js
{
	limit: 2,
	methods: [
		'GET',
		'PUT',
		'HEAD',
		'DELETE',
		'OPTIONS',
		'TRACE',
		'QUERY'
	],
	statusCodes: [
		408,
		413,
		429,
		500,
		502,
		503,
		504,
		521,
		522,
		524
	],
	errorCodes: [
		'ETIMEDOUT',
		'ECONNRESET',
		'EADDRINUSE',
		'ECONNREFUSED',
		'EPIPE',
		'ENOTFOUND',
		'ENETUNREACH',
		'EAI_AGAIN'
	],
	maxRetryAfter: undefined,
	calculateDelay: ({computedValue}) => computedValue,
	backoffLimit: Number.POSITIVE_INFINITY,
	noise: 100
}
```

This option represents the `retry` object.

#### `limit`

**Type: `number`**

The maximum retry count.

#### `methods`

**Type: `string[]`**

The allowed methods to retry on.

**Note:**
> - By default, Got does not retry on `POST`.

#### `statusCodes`

**Type: `number[]`**

**Note:**
> - Only [**unsuccessful**](8-errors.md#) requests are retried. In order to retry successful requests, use an [`afterResponse`](9-hooks.md#afterresponse) hook.

The allowed [HTTP status codes](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status) to retry on.

#### `errorCodes`

**Type: `string[]`**

The allowed error codes to retry on.

- `ETIMEDOUT` - One of the [timeout limits](6-timeout.md) was reached.
- `ECONNRESET`- The connection was forcibly closed.
- `EADDRINUSE`- Could not bind to any free port.
- `ECONNREFUSED`- The connection was refused by the server.
- `EPIPE` - The remote side of the stream being written has been closed.
- `ENOTFOUND` - Could not resolve the hostname to an IP address.
- `ENETUNREACH` - No internet connection.
- `EAI_AGAIN` - DNS lookup timed out.

#### `maxRetryAfter`

**Type: `number | undefined`**\
**Default: `options.timeout.request`**

The upper limit of [`retry-after` header](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Retry-After). If `undefined`, it will use `options.timeout` as the value.

If the limit is exceeded, the request is aborted.

#### `calculateDelay`

**Type: `Function`**

```ts
(retryObject: RetryObject) => Promisable<number>
```

```ts
interface RetryObject {
	attemptCount: number;
	retryOptions: RetryOptions;
	error: RequestError;
	computedValue: number;
	retryAfter?: number;
}
```

The function used to calculate the delay before the next request is made. Returning `0` aborts the retry.

**Note:**
> - By default, retry rules are enforced before `calculateDelay` runs (`enforceRetryRules: true`), so this function is only called when a retry is allowed.
> - If you set `enforceRetryRules: false`, `calculateDelay` takes full control of retry behavior. In that mode, check `computedValue` and return `0` when it is `0` to preserve default retry safeguards.

**Tip:**
> - This is especially useful when you want to scale down the computed value.

```js
import got from 'got';

await got('https://httpbin.org/anything', {
	retry: {
		limit: 3,
		calculateDelay: ({computedValue}) => {
			// When computedValue is 0, the default logic says don't retry
			// (limit exceeded, non-retryable error, etc.)
			if (computedValue === 0) {
				return 0;
			}

			// Scale down the delay
			return computedValue / 10;
		}
	}
});
```

#### `backoffLimit`

**Type: `number`**

The upper limit of the `computedValue`.

By default, the `computedValue` is calculated in the following way:

```ts
((2 ** (attemptCount - 1)) * 1000) + noise
```

The delay increases exponentially.\
In order to prevent this, you can set this value to a fixed value, such as `1000`.

#### `noise`

**Type: `number`**

The maximum acceptable retry noise in the range of `-100` to `+100`.

import {errorMonitor} from 'node:events';
import {types} from 'node:util';
import type {ClientRequest, IncomingMessage} from 'node:http';
import type {Socket} from 'node:net';
import deferToConnect from './defer-to-connect.js';

type InitialConnectionTimings = {
	dnsPhase: number;
	tcpPhase: number;
	tlsPhase?: number;
};

const getInitialConnectionTimings = (socket: Socket): InitialConnectionTimings | undefined => Reflect.get(socket, '__initial_connection_timings__');

const setInitialConnectionTimings = (socket: Socket, timings: InitialConnectionTimings): void => {
	Reflect.set(socket, '__initial_connection_timings__', timings);
};

export type Timings = {
	start: number;
	socket?: number;
	lookup?: number;
	connect?: number;
	secureConnect?: number;
	upload?: number;
	response?: number;
	end?: number;
	error?: number;
	abort?: number;
	phases: {
		wait?: number;
		dns?: number;
		tcp?: number;
		tls?: number;
		request?: number;
		firstByte?: number;
		download?: number;
		total?: number;
	};
};

export type ClientRequestWithTimings = ClientRequest & {
	timings?: Timings;
};

export type IncomingMessageWithTimings = IncomingMessage & {
	timings?: Timings;
};

const timer = (request: ClientRequestWithTimings): Timings => {
	if (request.timings) {
		return request.timings;
	}

	const timings: Timings = {
		start: Date.now(),
		socket: undefined,
		lookup: undefined,
		connect: undefined,
		secureConnect: undefined,
		upload: undefined,
		response: undefined,
		end: undefined,
		error: undefined,
		abort: undefined,
		phases: {
			wait: undefined,
			dns: undefined,
			tcp: undefined,
			tls: undefined,
			request: undefined,
			firstByte: undefined,
			download: undefined,
			total: undefined,
		},
	};

	request.timings = timings;

	const handleError = (origin: ClientRequest | IncomingMessage) => {
		origin.once(errorMonitor, () => {
			timings.error = Date.now();
			timings.phases.total = timings.error - timings.start;
		});
	};

	handleError(request);

	const onAbort = () => {
		timings.abort = Date.now();
		timings.phases.total = timings.abort - timings.start;
	};

	request.prependOnceListener('abort', onAbort);

	const onSocket = (socket: Socket) => {
		timings.socket = Date.now();
		timings.phases.wait = timings.socket - timings.start;

		if (types.isProxy(socket)) {
			// HTTP/2: The socket is a proxy, so connection events won't fire.
			// We can't measure connection timings, so leave them undefined.
			// This prevents NaN in phases.request calculation.
			return;
		}

		// Check if socket is already connected (reused from connection pool)
		const socketAlreadyConnected = socket.writable && !socket.connecting;

		if (socketAlreadyConnected) {
			// Socket reuse detected: the socket was already connected from a previous request.
			// For reused sockets, set all connection timestamps to socket time since no new
			// connection was made for THIS request. But preserve phase durations from the
			// original connection so they're not lost.
			timings.lookup = timings.socket;
			timings.connect = timings.socket;

			const initialConnectionTimings = getInitialConnectionTimings(socket);

			if (initialConnectionTimings) {
				// Restore the phase timings from the initial connection
				timings.phases.dns = initialConnectionTimings.dnsPhase;
				timings.phases.tcp = initialConnectionTimings.tcpPhase;
				timings.phases.tls = initialConnectionTimings.tlsPhase;

				// Set secureConnect timestamp if there was TLS
				if (timings.phases.tls !== undefined) {
					timings.secureConnect = timings.socket;
				}
			} else {
				// Socket reused but no initial timings stored (e.g., from external code)
				// Set phases to 0
				timings.phases.dns = 0;
				timings.phases.tcp = 0;
			}

			return;
		}

		const lookupListener = () => {
			timings.lookup = Date.now();
			timings.phases.dns = timings.lookup - timings.socket!;
		};

		socket.prependOnceListener('lookup', lookupListener);

		deferToConnect(socket, {
			connect() {
				timings.connect = Date.now();
				if (timings.lookup === undefined) {
					// No DNS lookup occurred (e.g., connecting to an IP address directly)
					// Set lookup to socket time (no time elapsed for DNS)
					socket.removeListener('lookup', lookupListener);
					timings.lookup = timings.socket!;
					timings.phases.dns = 0;
				}

				timings.phases.tcp = timings.connect - timings.lookup;

				// If lookup and connect happen at the EXACT same time (tcp = 0),
				// DNS was served from cache and the dns value is just event loop overhead.
				// Set dns to 0 to indicate no actual DNS resolution occurred.
				// Fixes https://github.com/szmarczak/http-timer/issues/35
				if (timings.phases.tcp === 0 && timings.phases.dns && timings.phases.dns > 0) {
					timings.phases.dns = 0;
				}

				// Store connection phase timings on socket for potential reuse
				if (!getInitialConnectionTimings(socket)) {
					setInitialConnectionTimings(socket, {
						dnsPhase: timings.phases.dns!,
						// eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion -- TypeScript can't prove this is defined due to callback structure
						tcpPhase: timings.phases.tcp!,
					});
				}
			},
			secureConnect() {
				timings.secureConnect = Date.now();
				timings.phases.tls = timings.secureConnect - timings.connect!;

				// Update stored timings with TLS phase timing
				const initialConnectionTimings = getInitialConnectionTimings(socket);

				if (initialConnectionTimings) {
					initialConnectionTimings.tlsPhase = timings.phases.tls;
				}
			},
		});
	};

	if (request.socket) {
		onSocket(request.socket);
	} else {
		request.prependOnceListener('socket', onSocket);
	}

	const onUpload = () => {
		timings.upload = Date.now();

		// Calculate request phase if we have connection timings
		const secureOrConnect = timings.secureConnect ?? timings.connect;
		if (secureOrConnect !== undefined) {
			timings.phases.request = timings.upload - secureOrConnect;
		}
		// If both are undefined (HTTP/2), phases.request stays undefined (not NaN)
	};

	if (request.writableFinished) {
		onUpload();
	} else {
		request.prependOnceListener('finish', onUpload);
	}

	request.prependOnceListener('response', (response: IncomingMessageWithTimings) => {
		timings.response = Date.now();
		timings.phases.firstByte = timings.response - timings.upload!;

		response.timings = timings;
		handleError(response);

		response.prependOnceListener('end', () => {
			request.off('abort', onAbort);
			response.off('aborted', onAbort);

			if (timings.phases.total !== undefined) {
				// Aborted or errored
				return;
			}

			timings.end = Date.now();
			timings.phases.download = timings.end - timings.response!;
			timings.phases.total = timings.end - timings.start;
		});

		response.prependOnceListener('aborted', onAbort);
	});

	return timings;
};

export default timer;

'use strict'

var express = require('../')
  , request = require('supertest')
  , assert = require('node:assert');
var utils = require('./support/utils');

describe('res', function(){
  describe('.jsonp(object)', function(){
    it('should respond with jsonp', function(done){
      var app = express();

      app.use(function(req, res){
        res.jsonp({ count: 1 });
      });

      request(app)
      .get('/?callback=something')
      .expect('Content-Type', 'text/javascript; charset=utf-8')
      .expect(200, /something\(\{"count":1\}\);/, done);
    })

    it('should use first callback parameter with jsonp', function(done){
      var app = express();

      app.use(function(req, res){
        res.jsonp({ count: 1 });
      });

      request(app)
      .get('/?callback=something&callback=somethingelse')
      .expect('Content-Type', 'text/javascript; charset=utf-8')
      .expect(200, /something\(\{"count":1\}\);/, done);
    })

    it('should ignore object callback parameter with jsonp', function(done){
      var app = express();

      app.use(function(req, res){
        res.jsonp({ count: 1 });
      });

      request(app)
      .get('/?callback[a]=something')
      .expect('Content-Type', 'application/json; charset=utf-8')
      .expect(200, '{"count":1}', done)
    })

    it('should allow renaming callback', function(done){
      var app = express();

      app.set('jsonp callback name', 'clb');

      app.use(function(req, res){
        res.jsonp({ count: 1 });
      });

      request(app)
      .get('/?clb=something')
      .expect('Content-Type', 'text/javascript; charset=utf-8')
      .expect(200, /something\(\{"count":1\}\);/, done);
    })

    it('should allow []', function(done){
      var app = express();

      app.use(function(req, res){
        res.jsonp({ count: 1 });
      });

      request(app)
      .get('/?callback=callbacks[123]')
      .expect('Content-Type', 'text/javascript; charset=utf-8')
      .expect(200, /callbacks\[123\]\(\{"count":1\}\);/, done);
    })

    it('should disallow arbitrary js', function(done){
      var app = express();

      app.use(function(req, res){
        res.jsonp({});
      });

      request(app)
      .get('/?callback=foo;bar()')
      .expect('Content-Type', 'text/javascript; charset=utf-8')
      .expect(200, /foobar\(\{\}\);/, done);
    })

    it('should escape utf whitespace', function(done){
      var app = express();

      app.use(function(req, res){
        res.jsonp({ str: '\u2028 \u2029 woot' });
      });

      request(app)
      .get('/?callback=foo')
      .expect('Content-Type', 'text/javascript; charset=utf-8')
      .expect(200, /foo\(\{"str":"\\u2028 \\u2029 woot"\}\);/, done);
    });

    it('should not escape utf whitespace for json fallback', function(done){
      var app = express();

      app.use(function(req, res){
        res.jsonp({ str: '\u2028 \u2029 woot' });
      });

      request(app)
      .get('/')
      .expect('Content-Type', 'application/json; charset=utf-8')
      .expect(200, '{"str":"\u2028 \u2029 woot"}', done);
    });

    it('should include security header and prologue', function (done) {
      var app = express();

      app.use(function(req, res){
        res.jsonp({ count: 1 });
      });

      request(app)
      .get('/?callback=something')
      .expect('Content-Type', 'text/javascript; charset=utf-8')
      .expect('X-Content-Type-Options', 'nosniff')
      .expect(200, /^\/\*\*\//, done);
    })

    it('should not override previous Content-Types with no callback', function(done){
      var app = express();

      app.get('/', function(req, res){
        res.type('application/vnd.example+json');
        res.jsonp({ hello: 'world' });
      });

      request(app)
      .get('/')
      .expect('Content-Type', 'application/vnd.example+json; charset=utf-8')
      .expect(utils.shouldNotHaveHeader('X-Content-Type-Options'))
      .expect(200, '{"hello":"world"}', done);
    })

    it('should override previous Content-Types with callback', function(done){
      var app = express();

      app.get('/', function(req, res){
        res.type('application/vnd.example+json');
        res.jsonp({ hello: 'world' });
      });

      request(app)
      .get('/?callback=cb')
      .expect('Content-Type', 'text/javascript; charset=utf-8')
      .expect('X-Content-Type-Options', 'nosniff')
      .expect(200, /cb\(\{"hello":"world"\}\);$/, done);
    })

    describe('when given undefined', function () {
      it('should invoke callback with no arguments', function (done) {
        var app = express()

        app.use(function (req, res) {
          res.jsonp(undefined)
        })

        request(app)
          .get('/?callback=cb')
          .expect('Content-Type', 'text/javascript; charset=utf-8')
          .expect(200, /cb\(\)/, done)
      })
    })

    describe('when given null', function () {
      it('should invoke callback with null', function (done) {
        var app = express()

        app.use(function (req, res) {
          res.jsonp(null)
        })

        request(app)
          .get('/?callback=cb')
          .expect('Content-Type', 'text/javascript; charset=utf-8')
          .expect(200, /cb\(null\)/, done)
      })
    })

    describe('when given a string', function () {
      it('should invoke callback with a string', function (done) {
        var app = express()

        app.use(function (req, res) {
          res.jsonp('tobi')
        })

        request(app)
          .get('/?callback=cb')
          .expect('Content-Type', 'text/javascript; charset=utf-8')
          .expect(200, /cb\("tobi"\)/, done)
      })
    })

    describe('when given a number', function () {
      it('should invoke callback with a number', function (done) {
        var app = express()

        app.use(function (req, res) {
          res.jsonp(42)
        })

        request(app)
          .get('/?callback=cb')
          .expect('Content-Type', 'text/javascript; charset=utf-8')
          .expect(200, /cb\(42\)/, done)
      })
    })

    describe('when given an array', function () {
      it('should invoke callback with an array', function (done) {
        var app = express()

        app.use(function (req, res) {
          res.jsonp(['foo', 'bar', 'baz'])
        })

        request(app)
          .get('/?callback=cb')
          .expect('Content-Type', 'text/javascript; charset=utf-8')
          .expect(200, /cb\(\["foo","bar","baz"\]\)/, done)
      })
    })

    describe('when given an object', function () {
      it('should invoke callback with an object', function (done) {
        var app = express()

        app.use(function (req, res) {
          res.jsonp({ name: 'tobi' })
        })

        request(app)
          .get('/?callback=cb')
          .expect('Content-Type', 'text/javascript; charset=utf-8')
          .expect(200, /cb\(\{"name":"tobi"\}\)/, done)
      })
    })

    describe('"json escape" setting', function () {
      it('should be undefined by default', function () {
        var app = express()
        assert.strictEqual(app.get('json escape'), undefined)
      })

      it('should unicode escape HTML-sniffing characters', function (done) {
        var app = express()

        app.enable('json escape')

        app.use(function (req, res) {
          res.jsonp({ '&': '\u2028<script>\u2029' })
        })

        request(app)
        .get('/?callback=foo')
        .expect('Content-Type', 'text/javascript; charset=utf-8')
        .expect(200, /foo\({"\\u0026":"\\u2028\\u003cscript\\u003e\\u2029"}\)/, done)
      })

      it('should not break undefined escape', function (done) {
        var app = express()

        app.enable('json escape')

        app.use(function (req, res) {
          res.jsonp(undefined)
        })

        request(app)
          .get('/?callback=cb')
          .expect('Content-Type', 'text/javascript; charset=utf-8')
          .expect(200, /cb\(\)/, done)
      })
    })

    describe('"json replacer" setting', function(){
      it('should be passed to JSON.stringify()', function(done){
        var app = express();

        app.set('json replacer', function(key, val){
          return key[0] === '_'
            ? undefined
            : val;
        });

        app.use(function(req, res){
          res.jsonp({ name: 'tobi', _id: 12345 });
        });

        request(app)
        .get('/')
        .expect('Content-Type', 'application/json; charset=utf-8')
        .expect(200, '{"name":"tobi"}', done)
      })
    })

    describe('"json spaces" setting', function(){
      it('should be undefined by default', function(){
        var app = express();
        assert(undefined === app.get('json spaces'));
      })

      it('should be passed to JSON.stringify()', function(done){
        var app = express();

        app.set('json spaces', 2);

        app.use(function(req, res){
          res.jsonp({ name: 'tobi', age: 2 });
        });

        request(app)
        .get('/')
        .expect('Content-Type', 'application/json; charset=utf-8')
        .expect(200, '{\n  "name": "tobi",\n  "age": 2\n}', done)
      })
    })
  })
})

'use strict'

var express = require('..');
var request = require('supertest');

describe('res', function(){
  describe('.get(field)', function(){
    it('should get the response header field', function (done) {
      var app = express();

      app.use(function (req, res) {
        res.setHeader('Content-Type', 'text/x-foo');
        res.send(res.get('Content-Type'));
      });

      request(app)
      .get('/')
      .expect(200, 'text/x-foo', done);
    })
  })
})

var app = require('../../examples/route-separation')
var request = require('supertest')

describe('route-separation', function () {
  describe('GET /', function () {
    it('should respond with index', function (done) {
      request(app)
      .get('/')
      .expect(200, /Route Separation Example/, done)
    })
  })

  describe('GET /users', function () {
    it('should list users', function (done) {
      request(app)
      .get('/users')
      .expect(/TJ/)
      .expect(/Tobi/)
      .expect(200, done)
    })
  })

  describe('GET /user/:id', function () {
    it('should get a user', function (done) {
      request(app)
      .get('/user/0')
      .expect(200, /Viewing user TJ/, done)
    })

    it('should 404 on missing user', function (done) {
      request(app)
      .get('/user/10')
      .expect(404, done)
    })
  })

  describe('GET /user/:id/view', function () {
    it('should get a user', function (done) {
      request(app)
      .get('/user/0/view')
      .expect(200, /Viewing user TJ/, done)
    })

    it('should 404 on missing user', function (done) {
      request(app)
      .get('/user/10/view')
      .expect(404, done)
    })
  })

  describe('GET /user/:id/edit', function () {
    it('should get a user to edit', function (done) {
      request(app)
      .get('/user/0/edit')
      .expect(200, /Editing user TJ/, done)
    })
  })

  describe('PUT /user/:id/edit', function () {
    it('should edit a user', function (done) {
      request(app)
      .put('/user/0/edit')
      .set('Content-Type', 'application/x-www-form-urlencoded')
      .send({ user: { name: 'TJ', email: 'tj-invalid@vision-media.ca' } })
      .expect(302, function (err) {
        if (err) return done(err)
        request(app)
        .get('/user/0')
        .expect(200, /tj-invalid@vision-media\.ca/, done)
      })
    })
  })

  describe('POST /user/:id/edit?_method=PUT', function () {
    it('should edit a user', function (done) {
      request(app)
      .post('/user/1/edit?_method=PUT')
      .set('Content-Type', 'application/x-www-form-urlencoded')
      .send({ user: { name: 'Tobi', email: 'tobi-invalid@vision-media.ca' } })
      .expect(302, function (err) {
        if (err) return done(err)
        request(app)
        .get('/user/1')
        .expect(200, /tobi-invalid@vision-media\.ca/, done)
      })
    })
  })

  describe('GET /posts', function () {
    it('should get a list of posts', function (done) {
      request(app)
      .get('/posts')
      .expect(200, /Posts/, done)
    })
  })
})

<!--
Before opening a PR, open a ticket describing the issue or feature the
PR will address. An issue is not required for fixing typos in
documentation, or other simple non-code changes.

Replace this comment with a description of the change. Describe how it
addresses the linked ticket.
-->

<!--
Link to relevant issues or previous PRs, one per line. Use "fixes" to
automatically close an issue.

fixes #<issue number>
-->

<!--
Ensure each step in CONTRIBUTING.rst is complete, especially the following:

- Add tests that demonstrate the correct behavior of the change. Tests
  should fail without the change.
- Add or update relevant docs, in the docs folder and in code.
- Add an entry in CHANGES.rst summarizing the change and linking to the issue.
- Add `.. versionchanged::` entries in any relevant code docs.
-->

import {EventEmitter} from 'node:events';
import is from '@sindresorhus/is';
import {
	HTTPError,
	RetryError,
	type RequestError,
} from '../core/errors.js';
import Request, {normalizeError} from '../core/index.js';
import {
	decodeUint8Array,
	isUtf8Encoding,
	parseBody,
	isResponseOk,
	type Response, ParseError,
} from '../core/response.js';
import proxyEvents from '../core/utils/proxy-events.js';
import {
	applyUrlOverride,
	assertUrlHasSameOriginAsPrefixUrlIfNeeded,
	getUrlPrefixBoundary,
	hasUrlOrPrefixUrlBoundaryChanged,
	isSameOrigin,
	snapshotCrossOriginState,
} from '../core/options.js';
import type Options from '../core/options.js';
import {type RequestPromise} from './types.js';

const compressedEncodings = new Set(['gzip', 'deflate', 'br', 'zstd']);

const proxiedRequestEvents = [
	'request',
	'response',
	'redirect',
	'uploadProgress',
	'downloadProgress',
];

export default function asPromise<T>(firstRequest?: Request): RequestPromise<T> {
	let globalRequest: Request;
	let globalResponse: Response;
	const emitter = new EventEmitter();
	let promiseSettled = false;

	const promise = new Promise<T>((resolve, reject) => {
		const makeRequest = (retryCount: number, defaultOptions?: Options): void => {
			const request = firstRequest ?? new Request(undefined, undefined, defaultOptions);
			request.retryCount = retryCount;
			request._noPipe = true;

			globalRequest = request;

			request.once('response', (response: Response) => {
				void (async () => {
				// Parse body
					const contentEncoding = (response.headers['content-encoding'] ?? '').toLowerCase();
					const isCompressed = compressedEncodings.has(contentEncoding);

					const {options} = request;

					if (isCompressed && !options.decompress) {
						response.body = response.rawBody;
					} else {
						try {
							response.body = parseBody(response, options.responseType, options.parseJson, options.encoding);
						} catch (error: unknown) {
						// Fall back to `utf8`
							try {
								response.body = decodeUint8Array(response.rawBody);
							} catch (error) {
								request._beforeError(new ParseError(normalizeError(error), response));
								return;
							}

							if (isResponseOk(response)) {
								request._beforeError(normalizeError(error));
								return;
							}
						}
					}

					try {
						const hooks = options.hooks.afterResponse;

						for (const [index, hook] of hooks.entries()) {
							const previousUrl = options.url ? new URL(options.url) : undefined;
							const previousBoundary = getUrlPrefixBoundary(options);
							const previousState = previousUrl ? snapshotCrossOriginState(options) : undefined;
							const requestOptions = response.request.options;
							const responseSnapshot = response;

							// @ts-expect-error TS doesn't notice that RequestPromise is a Promise
							// eslint-disable-next-line no-await-in-loop
							response = await requestOptions.trackStateMutations(async changedState => hook(responseSnapshot, async (updatedOptions): RequestPromise<Response> => {
								const preserveHooks = updatedOptions.preserveHooks ?? false;
								const reusesRequestOptions = updatedOptions === requestOptions;
								const hasExplicitBody = reusesRequestOptions
									? changedState.has('body') || changedState.has('json') || changedState.has('form')
									: (Object.hasOwn(updatedOptions, 'body') && updatedOptions.body !== undefined)
										|| (Object.hasOwn(updatedOptions, 'json') && updatedOptions.json !== undefined)
										|| (Object.hasOwn(updatedOptions, 'form') && updatedOptions.form !== undefined);
								const clearsCookieJar = Object.hasOwn(updatedOptions, 'cookieJar') && updatedOptions.cookieJar === undefined;

								if (hasExplicitBody && !reusesRequestOptions) {
									options.clearBody();
								}

								if (!reusesRequestOptions && clearsCookieJar) {
									options.cookieJar = undefined;
								}

								if (!reusesRequestOptions) {
									const {url, ...updatedOptionsWithoutUrl} = updatedOptions;
									options.merge(updatedOptionsWithoutUrl);
									options.syncCookieHeaderAfterMerge(previousState, updatedOptionsWithoutUrl.headers);
								}

								options.clearUnchangedCookieHeader(previousState, reusesRequestOptions ? changedState : undefined);

								const currentUrl = options.url;
								if (
									previousUrl
									&& currentUrl instanceof URL
									&& hasUrlOrPrefixUrlBoundaryChanged(options, currentUrl, previousBoundary)
								) {
									assertUrlHasSameOriginAsPrefixUrlIfNeeded(options, currentUrl);
								}

								if (
									!reusesRequestOptions
									&& updatedOptions.url === undefined
									&& previousUrl
									&& currentUrl instanceof URL
									&& !isSameOrigin(previousUrl, currentUrl)
								) {
									options.stripSensitiveHeaders(previousUrl, currentUrl, updatedOptions);

									if (!hasExplicitBody) {
										options.clearBody();
									}
								}

								if (updatedOptions.url !== undefined) {
									const nextUrl = reusesRequestOptions
										? options.url as URL
										: applyUrlOverride(options, updatedOptions.url, updatedOptions);

									if (previousUrl) {
										if (reusesRequestOptions && !isSameOrigin(previousUrl, nextUrl)) {
											options.stripUnchangedCrossOriginState(previousState!, changedState, {clearBody: !hasExplicitBody});
										} else {
											options.stripSensitiveHeaders(previousUrl, nextUrl, updatedOptions);

											if (!isSameOrigin(previousUrl, nextUrl) && !hasExplicitBody) {
												options.clearBody();
											}
										}
									}
								}

								// Remove any further hooks for that request, because we'll call them anyway.
								// The loop continues. We don't want duplicates (asPromise recursion).
								// Unless preserveHooks is true, in which case we keep the remaining hooks.
								if (!preserveHooks) {
									options.hooks.afterResponse = options.hooks.afterResponse.slice(0, index);
								}

								throw new RetryError(request);
							}));

							if (!(is.object(response) && is.number(response.statusCode) && 'body' in response)) {
								throw new TypeError('The `afterResponse` hook returned an invalid value');
							}
						}
					} catch (error: unknown) {
						request._beforeError(normalizeError(error));
						return;
					}

					globalResponse = response;

					if (!isResponseOk(response)) {
						request._beforeError(new HTTPError(response));
						return;
					}

					request.destroy();
					promiseSettled = true;
					resolve(request.options.resolveBodyOnly ? response.body as T : response as unknown as T);
				})();
			});

			let handledFinalError = false;

			const onError = (error: RequestError) => {
				// Route errors emitted directly on the stream (e.g., EPIPE from Node.js)
				// through retry logic first, then handle them here after retries are exhausted.
				// See https://github.com/sindresorhus/got/issues/1995
				if (!request._stopReading) {
					request._beforeError(error);
					return;
				}

				// Allow the manual re-emission from Request to land only once.
				if (handledFinalError) {
					return;
				}

				handledFinalError = true;

				promiseSettled = true;
				const {options} = request;

				if (error instanceof HTTPError && !options.throwHttpErrors) {
					const {response} = error;

					request.destroy();
					resolve(request.options.resolveBodyOnly ? response.body as T : response as unknown as T);
					return;
				}

				reject(error);
			};

			// Use .on() instead of .once() to keep the listener active across retries.
			// When _stopReading is false, we return early and the error gets re-emitted
			// after retry logic completes, so we need this listener to remain active.
			// See https://github.com/sindresorhus/got/issues/1995
			request.on('error', onError);

			const previousBody = request.options?.body;

			request.once('retry', (newRetryCount: number, error: RequestError) => {
				firstRequest = undefined;

				// If promise already settled, don't retry
				// This prevents the race condition in #1489 where a late error
				// (e.g., ECONNRESET after successful response) triggers retry
				// after the promise has already resolved/rejected
				if (promiseSettled) {
					return;
				}

				const newBody = request.options.body;

				if (previousBody === newBody && (is.nodeStream(newBody) || newBody instanceof ReadableStream)) {
					error.message = 'Cannot retry with consumed body stream';

					onError(error);
					return;
				}

				// This is needed! We need to reuse `request.options` because they can get modified!
				// For example, by calling `promise.json()`.
				makeRequest(newRetryCount, request.options);
			});

			proxyEvents(request, emitter, proxiedRequestEvents);

			if (is.undefined(firstRequest)) {
				void request.flush();
			}
		};

		makeRequest(0);
	}) as RequestPromise<T>;

	promise.on = function (this: RequestPromise<T>, event: string, function_: (...arguments_: any[]) => void) {
		emitter.on(event, function_);
		return this;
	};

	promise.once = function (this: RequestPromise<T>, event: string, function_: (...arguments_: any[]) => void) {
		emitter.once(event, function_);
		return this;
	};

	promise.off = function (this: RequestPromise<T>, event: string, function_: (...arguments_: any[]) => void) {
		emitter.off(event, function_);
		return this;
	};

	const shortcut = <T>(promiseToAwait: RequestPromise, responseType: Options['responseType']): RequestPromise<T> => {
		const newPromise = (async () => {
			// Wait until downloading has ended
			await promiseToAwait;

			const {options} = globalResponse.request;

			if (responseType === 'text') {
				const text = decodeUint8Array(globalResponse.rawBody, options.encoding);
				return (isUtf8Encoding(options.encoding) ? text.replace(/^\u{FEFF}/v, '') : text) as T;
			}

			return parseBody(globalResponse, responseType, options.parseJson, options.encoding);
		})();

		// eslint-disable-next-line @typescript-eslint/no-floating-promises
		Object.defineProperties(newPromise, Object.getOwnPropertyDescriptors(promiseToAwait));

		return newPromise as RequestPromise<T>;
	};

	// Note: These use `function` syntax (not arrows) to access `this` context.
	// When custom handlers wrap the promise to transform errors, these methods
	// are copied to the handler's promise. Using `this` ensures we await the
	// handler's wrapped promise, not the original, so errors propagate correctly.
	promise.json = function (this: RequestPromise) {
		if (globalRequest.options) {
			const {headers} = globalRequest.options;

			if (!globalRequest.writableFinished && !('accept' in headers)) {
				headers.accept = 'application/json';
			}
		}

		return shortcut(this, 'json');
	};

	promise.buffer = function (this: RequestPromise) {
		return shortcut(this, 'buffer');
	};

	promise.text = function (this: RequestPromise) {
		return shortcut(this, 'text');
	};

	return promise;
}

"""The runtime functions and state used by compiled templates."""

import functools
import sys
import typing as t
from collections import abc
from itertools import chain

from markupsafe import escape  # noqa: F401
from markupsafe import Markup
from markupsafe import soft_str

from .async_utils import auto_aiter
from .async_utils import auto_await  # noqa: F401
from .exceptions import TemplateNotFound  # noqa: F401
from .exceptions import TemplateRuntimeError  # noqa: F401
from .exceptions import UndefinedError
from .nodes import EvalContext
from .utils import _PassArg
from .utils import concat
from .utils import internalcode
from .utils import missing
from .utils import Namespace  # noqa: F401
from .utils import object_type_repr
from .utils import pass_eval_context

V = t.TypeVar("V")
F = t.TypeVar("F", bound=t.Callable[..., t.Any])

if t.TYPE_CHECKING:
    import logging

    import typing_extensions as te

    from .environment import Environment

    class LoopRenderFunc(te.Protocol):
        def __call__(
            self,
            reciter: t.Iterable[V],
            loop_render_func: "LoopRenderFunc",
            depth: int = 0,
        ) -> str: ...


# these variables are exported to the template runtime
exported = [
    "LoopContext",
    "TemplateReference",
    "Macro",
    "Markup",
    "TemplateRuntimeError",
    "missing",
    "escape",
    "markup_join",
    "str_join",
    "identity",
    "TemplateNotFound",
    "Namespace",
    "Undefined",
    "internalcode",
]
async_exported = [
    "AsyncLoopContext",
    "auto_aiter",
    "auto_await",
]


def identity(x: V) -> V:
    """Returns its argument. Useful for certain things in the
    environment.
    """
    return x


def markup_join(seq: t.Iterable[t.Any]) -> str:
    """Concatenation that escapes if necessary and converts to string."""
    buf = []
    iterator = map(soft_str, seq)
    for arg in iterator:
        buf.append(arg)
        if hasattr(arg, "__html__"):
            return Markup("").join(chain(buf, iterator))
    return concat(buf)


def str_join(seq: t.Iterable[t.Any]) -> str:
    """Simple args to string conversion and concatenation."""
    return concat(map(str, seq))


def new_context(
    environment: "Environment",
    template_name: str | None,
    blocks: dict[str, t.Callable[["Context"], t.Iterator[str]]],
    vars: dict[str, t.Any] | None = None,
    shared: bool = False,
    globals: t.MutableMapping[str, t.Any] | None = None,
    locals: t.Mapping[str, t.Any] | None = None,
) -> "Context":
    """Internal helper for context creation."""
    if vars is None:
        vars = {}
    if shared:
        parent = vars
    else:
        parent = dict(globals or (), **vars)
    if locals:
        # if the parent is shared a copy should be created because
        # we don't want to modify the dict passed
        if shared:
            parent = dict(parent)
        for key, value in locals.items():
            if value is not missing:
                parent[key] = value
    return environment.context_class(
        environment, parent, template_name, blocks, globals=globals
    )


class TemplateReference:
    """The `self` in templates."""

    def __init__(self, context: "Context") -> None:
        self.__context = context

    def __getitem__(self, name: str) -> t.Any:
        blocks = self.__context.blocks[name]
        return BlockReference(name, self.__context, blocks, 0)

    def __repr__(self) -> str:
        return f"<{type(self).__name__} {self.__context.name!r}>"


def _dict_method_all(dict_method: F) -> F:
    @functools.wraps(dict_method)
    def f_all(self: "Context") -> t.Any:
        return dict_method(self.get_all())

    return t.cast(F, f_all)


@abc.Mapping.register
class Context:
    """The template context holds the variables of a template.  It stores the
    values passed to the template and also the names the template exports.
    Creating instances is neither supported nor useful as it's created
    automatically at various stages of the template evaluation and should not
    be created by hand.

    The context is immutable.  Modifications on :attr:`parent` **must not**
    happen and modifications on :attr:`vars` are allowed from generated
    template code only.  Template filters and global functions marked as
    :func:`pass_context` get the active context passed as first argument
    and are allowed to access the context read-only.

    The template context supports read only dict operations (`get`,
    `keys`, `values`, `items`, `iterkeys`, `itervalues`, `iteritems`,
    `__getitem__`, `__contains__`).  Additionally there is a :meth:`resolve`
    method that doesn't fail with a `KeyError` but returns an
    :class:`Undefined` object for missing variables.
    """

    def __init__(
        self,
        environment: "Environment",
        parent: dict[str, t.Any],
        name: str | None,
        blocks: dict[str, t.Callable[["Context"], t.Iterator[str]]],
        globals: t.MutableMapping[str, t.Any] | None = None,
    ):
        self.parent = parent
        self.vars: dict[str, t.Any] = {}
        self.environment: Environment = environment
        self.eval_ctx = EvalContext(self.environment, name)
        self.exported_vars: set[str] = set()
        self.name = name
        self.globals_keys = set() if globals is None else set(globals)

        # create the initial mapping of blocks.  Whenever template inheritance
        # takes place the runtime will update this mapping with the new blocks
        # from the template.
        self.blocks = {k: [v] for k, v in blocks.items()}

    def super(
        self, name: str, current: t.Callable[["Context"], t.Iterator[str]]
    ) -> t.Union["BlockReference", "Undefined"]:
        """Render a parent block."""
        try:
            blocks = self.blocks[name]
            index = blocks.index(current) + 1
            blocks[index]
        except LookupError:
            return self.environment.undefined(
                f"there is no parent block called {name!r}.", name="super"
            )
        return BlockReference(name, self, blocks, index)

    def get(self, key: str, default: t.Any = None) -> t.Any:
        """Look up a variable by name, or return a default if the key is
        not found.

        :param key: The variable name to look up.
        :param default: The value to return if the key is not found.
        """
        try:
            return self[key]
        except KeyError:
            return default

    def resolve(self, key: str) -> t.Union[t.Any, "Undefined"]:
        """Look up a variable by name, or return an :class:`Undefined`
        object if the key is not found.

        If you need to add custom behavior, override
        :meth:`resolve_or_missing`, not this method. The various lookup
        functions use that method, not this one.

        :param key: The variable name to look up.
        """
        rv = self.resolve_or_missing(key)

        if rv is missing:
            return self.environment.undefined(name=key)

        return rv

    def resolve_or_missing(self, key: str) -> t.Any:
        """Look up a variable by name, or return a ``missing`` sentinel
        if the key is not found.

        Override this method to add custom lookup behavior.
        :meth:`resolve`, :meth:`get`, and :meth:`__getitem__` use this
        method. Don't call this method directly.

        :param key: The variable name to look up.
        """
        if key in self.vars:
            return self.vars[key]

        if key in self.parent:
            return self.parent[key]

        return missing

    def get_exported(self) -> dict[str, t.Any]:
        """Get a new dict with the exported variables."""
        return {k: self.vars[k] for k in self.exported_vars}

    def get_all(self) -> dict[str, t.Any]:
        """Return the complete context as dict including the exported
        variables.  For optimizations reasons this might not return an
        actual copy so be careful with using it.
        """
        if not self.vars:
            return self.parent
        if not self.parent:
            return self.vars
        return dict(self.parent, **self.vars)

    @internalcode
    def call(
        __self,  # noqa: B902
        __obj: t.Callable[..., t.Any],
        *args: t.Any,
        **kwargs: t.Any,
    ) -> t.Union[t.Any, "Undefined"]:
        """Call the callable with the arguments and keyword arguments
        provided but inject the active context or environment as first
        argument if the callable has :func:`pass_context` or
        :func:`pass_environment`.
        """
        if __debug__:
            __traceback_hide__ = True  # noqa

        # Allow callable classes to take a context
        if (
            hasattr(__obj, "__call__")  # noqa: B004
            and _PassArg.from_obj(__obj.__call__) is not None
        ):
            __obj = __obj.__call__

        pass_arg = _PassArg.from_obj(__obj)

        if pass_arg is _PassArg.context:
            # the active context should have access to variables set in
            # loops and blocks without mutating the context itself
            if kwargs.get("_loop_vars"):
                __self = __self.derived(kwargs["_loop_vars"])
            if kwargs.get("_block_vars"):
                __self = __self.derived(kwargs["_block_vars"])
            args = (__self,) + args
        elif pass_arg is _PassArg.eval_context:
            args = (__self.eval_ctx,) + args
        elif pass_arg is _PassArg.environment:
            args = (__self.environment,) + args

        kwargs.pop("_block_vars", None)
        kwargs.pop("_loop_vars", None)

        try:
            return __obj(*args, **kwargs)
        except StopIteration:
            return __self.environment.undefined(
                "value was undefined because a callable raised a"
                " StopIteration exception"
            )

    def derived(self, locals: dict[str, t.Any] | None = None) -> "Context":
        """Internal helper function to create a derived context.  This is
        used in situations where the system needs a new context in the same
        template that is independent.
        """
        context = new_context(
            self.environment, self.name, {}, self.get_all(), True, None, locals
        )
        context.eval_ctx = self.eval_ctx
        context.blocks.update((k, list(v)) for k, v in self.blocks.items())
        return context

    keys = _dict_method_all(dict.keys)
    values = _dict_method_all(dict.values)
    items = _dict_method_all(dict.items)

    def __contains__(self, name: str) -> bool:
        return name in self.vars or name in self.parent

    def __getitem__(self, key: str) -> t.Any:
        """Look up a variable by name with ``[]`` syntax, or raise a
        ``KeyError`` if the key is not found.
        """
        item = self.resolve_or_missing(key)

        if item is missing:
            raise KeyError(key)

        return item

    def __repr__(self) -> str:
        return f"<{type(self).__name__} {self.get_all()!r} of {self.name!r}>"


class BlockReference:
    """One block on a template reference."""

    def __init__(
        self,
        name: str,
        context: "Context",
        stack: list[t.Callable[["Context"], t.Iterator[str]]],
        depth: int,
    ) -> None:
        self.name = name
        self._context = context
        self._stack = stack
        self._depth = depth

    @property
    def super(self) -> t.Union["BlockReference", "Undefined"]:
        """Super the block."""
        if self._depth + 1 >= len(self._stack):
            return self._context.environment.undefined(
                f"there is no parent block called {self.name!r}.", name="super"
            )
        return BlockReference(self.name, self._context, self._stack, self._depth + 1)

    @internalcode
    async def _async_call(self) -> str:
        rv = self._context.environment.concat(  # type: ignore
            [x async for x in self._stack[self._depth](self._context)]  # type: ignore
        )

        if self._context.eval_ctx.autoescape:
            return Markup(rv)

        return rv

    @internalcode
    def __call__(self) -> str:
        if self._context.environment.is_async:
            return self._async_call()  # type: ignore

        rv = self._context.environment.concat(  # type: ignore
            self._stack[self._depth](self._context)
        )

        if self._context.eval_ctx.autoescape:
            return Markup(rv)

        return rv


class LoopContext:
    """A wrapper iterable for dynamic ``for`` loops, with information
    about the loop and iteration.
    """

    #: Current iteration of the loop, starting at 0.
    index0 = -1

    _length: int | None = None
    _after: t.Any = missing
    _current: t.Any = missing
    _before: t.Any = missing
    _last_changed_value: t.Any = missing

    def __init__(
        self,
        iterable: t.Iterable[V],
        undefined: type["Undefined"],
        recurse: t.Optional["LoopRenderFunc"] = None,
        depth0: int = 0,
    ) -> None:
        """
        :param iterable: Iterable to wrap.
        :param undefined: :class:`Undefined` class to use for next and
            previous items.
        :param recurse: The function to render the loop body when the
            loop is marked recursive.
        :param depth0: Incremented when looping recursively.
        """
        self._iterable = iterable
        self._iterator = self._to_iterator(iterable)
        self._undefined = undefined
        self._recurse = recurse
        #: How many levels deep a recursive loop currently is, starting at 0.
        self.depth0 = depth0

    @staticmethod
    def _to_iterator(iterable: t.Iterable[V]) -> t.Iterator[V]:
        return iter(iterable)

    @property
    def length(self) -> int:
        """Length of the iterable.

        If the iterable is a generator or otherwise does not have a
        size, it is eagerly evaluated to get a size.
        """
        if self._length is not None:
            return self._length

        try:
            self._length = len(self._iterable)  # type: ignore
        except TypeError:
            iterable = list(self._iterator)
            self._iterator = self._to_iterator(iterable)
            self._length = len(iterable) + self.index + (self._after is not missing)

        return self._length

    def __len__(self) -> int:
        return self.length

    @property
    def depth(self) -> int:
        """How many levels deep a recursive loop currently is, starting at 1."""
        return self.depth0 + 1

    @property
    def index(self) -> int:
        """Current iteration of the loop, starting at 1."""
        return self.index0 + 1

    @property
    def revindex0(self) -> int:
        """Number of iterations from the end of the loop, ending at 0.

        Requires calculating :attr:`length`.
        """
        return self.length - self.index

    @property
    def revindex(self) -> int:
        """Number of iterations from the end of the loop, ending at 1.

        Requires calculating :attr:`length`.
        """
        return self.length - self.index0

    @property
    def first(self) -> bool:
        """Whether this is the first iteration of the loop."""
        return self.index0 == 0

    def _peek_next(self) -> t.Any:
        """Return the next element in the iterable, or :data:`missing`
        if the iterable is exhausted. Only peeks one item ahead, caching
        the result in :attr:`_last` for use in subsequent checks. The
        cache is reset when :meth:`__next__` is called.
        """
        if self._after is not missing:
            return self._after

        self._after = next(self._iterator, missing)
        return self._after

    @property
    def last(self) -> bool:
        """Whether this is the last iteration of the loop.

        Causes the iterable to advance early. See
        :func:`itertools.groupby` for issues this can cause.
        The :func:`groupby` filter avoids that issue.
        """
        return self._peek_next() is missing

    @property
    def previtem(self) -> t.Union[t.Any, "Undefined"]:
        """The item in the previous iteration. Undefined during the
        first iteration.
        """
        if self.first:
            return self._undefined("there is no previous item")

        return self._before

    @property
    def nextitem(self) -> t.Union[t.Any, "Undefined"]:
        """The item in the next iteration. Undefined during the last
        iteration.

        Causes the iterable to advance early. See
        :func:`itertools.groupby` for issues this can cause.
        The :func:`jinja-filters.groupby` filter avoids that issue.
        """
        rv = self._peek_next()

        if rv is missing:
            return self._undefined("there is no next item")

        return rv

    def cycle(self, *args: V) -> V:
        """Return a value from the given args, cycling through based on
        the current :attr:`index0`.

        :param args: One or more values to cycle through.
        """
        if not args:
            raise TypeError("no items for cycling given")

        return args[self.index0 % len(args)]

    def changed(self, *value: t.Any) -> bool:
        """Return ``True`` if previously called with a different value
        (including when called for the first time).

        :param value: One or more values to compare to the last call.
        """
        if self._last_changed_value != value:
            self._last_changed_value = value
            return True

        return False

    def __iter__(self) -> "LoopContext":
        return self

    def __next__(self) -> tuple[t.Any, "LoopContext"]:
        if self._after is not missing:
            rv = self._after
            self._after = missing
        else:
            rv = next(self._iterator)

        self.index0 += 1
        self._before = self._current
        self._current = rv
        return rv, self

    @internalcode
    def __call__(self, iterable: t.Iterable[V]) -> str:
        """When iterating over nested data, render the body of the loop
        recursively with the given inner iterable data.

        The loop must have the ``recursive`` marker for this to work.
        """
        if self._recurse is None:
            raise TypeError(
                "The loop must have the 'recursive' marker to be called recursively."
            )

        return self._recurse(iterable, self._recurse, depth=self.depth)

    def __repr__(self) -> str:
        return f"<{type(self).__name__} {self.index}/{self.length}>"


class AsyncLoopContext(LoopContext):
    _iterator: t.AsyncIterator[t.Any]  # type: ignore

    @staticmethod
    def _to_iterator(  # type: ignore
        iterable: t.Iterable[V] | t.AsyncIterable[V],
    ) -> t.AsyncIterator[V]:
        return auto_aiter(iterable)

    @property
    async def length(self) -> int:  # type: ignore
        if self._length is not None:
            return self._length

        try:
            self._length = len(self._iterable)  # type: ignore
        except TypeError:
            iterable = [x async for x in self._iterator]
            self._iterator = self._to_iterator(iterable)
            self._length = len(iterable) + self.index + (self._after is not missing)

        return self._length

    @property
    async def revindex0(self) -> int:  # type: ignore
        return await self.length - self.index

    @property
    async def revindex(self) -> int:  # type: ignore
        return await self.length - self.index0

    async def _peek_next(self) -> t.Any:
        if self._after is not missing:
            return self._after

        try:
            self._after = await self._iterator.__anext__()
        except StopAsyncIteration:
            self._after = missing

        return self._after

    @property
    async def last(self) -> bool:  # type: ignore
        return await self._peek_next() is missing

    @property
    async def nextitem(self) -> t.Union[t.Any, "Undefined"]:
        rv = await self._peek_next()

        if rv is missing:
            return self._undefined("there is no next item")

        return rv

    def __aiter__(self) -> "AsyncLoopContext":
        return self

    async def __anext__(self) -> tuple[t.Any, "AsyncLoopContext"]:
        if self._after is not missing:
            rv = self._after
            self._after = missing
        else:
            rv = await self._iterator.__anext__()

        self.index0 += 1
        self._before = self._current
        self._current = rv
        return rv, self


class Macro:
    """Wraps a macro function."""

    def __init__(
        self,
        environment: "Environment",
        func: t.Callable[..., str],
        name: str,
        arguments: list[str],
        catch_kwargs: bool,
        catch_varargs: bool,
        caller: bool,
        default_autoescape: bool | None = None,
    ):
        self._environment = environment
        self._func = func
        self._argument_count = len(arguments)
        self.name = name
        self.arguments = arguments
        self.catch_kwargs = catch_kwargs
        self.catch_varargs = catch_varargs
        self.caller = caller
        self.explicit_caller = "caller" in arguments

        if default_autoescape is None:
            if callable(environment.autoescape):
                default_autoescape = environment.autoescape(None)
            else:
                default_autoescape = environment.autoescape

        self._default_autoescape = default_autoescape

    @internalcode
    @pass_eval_context
    def __call__(self, *args: t.Any, **kwargs: t.Any) -> str:
        # This requires a bit of explanation,  In the past we used to
        # decide largely based on compile-time information if a macro is
        # safe or unsafe.  While there was a volatile mode it was largely
        # unused for deciding on escaping.  This turns out to be
        # problematic for macros because whether a macro is safe depends not
        # on the escape mode when it was defined, but rather when it was used.
        #
        # Because however we export macros from the module system and
        # there are historic callers that do not pass an eval context (and
        # will continue to not pass one), we need to perform an instance
        # check here.
        #
        # This is considered safe because an eval context is not a valid
        # argument to callables otherwise anyway.  Worst case here is
        # that if no eval context is passed we fall back to the compile
        # time autoescape flag.
        if args and isinstance(args[0], EvalContext):
            autoescape = args[0].autoescape
            args = args[1:]
        else:
            autoescape = self._default_autoescape

        # try to consume the positional arguments
        arguments = list(args[: self._argument_count])
        off = len(arguments)

        # For information why this is necessary refer to the handling
        # of caller in the `macro_body` handler in the compiler.
        found_caller = False

        # if the number of arguments consumed is not the number of
        # arguments expected we start filling in keyword arguments
        # and defaults.
        if off != self._argument_count:
            for name in self.arguments[len(arguments) :]:
                try:
                    value = kwargs.pop(name)
                except KeyError:
                    value = missing
                if name == "caller":
                    found_caller = True
                arguments.append(value)
        else:
            found_caller = self.explicit_caller

        # it's important that the order of these arguments does not change
        # if not also changed in the compiler's `function_scoping` method.
        # the order is caller, keyword arguments, positional arguments!
        if self.caller and not found_caller:
            caller = kwargs.pop("caller", None)
            if caller is None:
                caller = self._environment.undefined("No caller defined", name="caller")
            arguments.append(caller)

        if self.catch_kwargs:
            arguments.append(kwargs)
        elif kwargs:
            if "caller" in kwargs:
                raise TypeError(
                    f"macro {self.name!r} was invoked with two values for the special"
                    " caller argument. This is most likely a bug."
                )
            raise TypeError(
                f"macro {self.name!r} takes no keyword argument {next(iter(kwargs))!r}"
            )
        if self.catch_varargs:
            arguments.append(args[self._argument_count :])
        elif len(args) > self._argument_count:
            raise TypeError(
                f"macro {self.name!r} takes not more than"
                f" {len(self.arguments)} argument(s)"
            )

        return self._invoke(arguments, autoescape)

    async def _async_invoke(self, arguments: list[t.Any], autoescape: bool) -> str:
        rv = await self._func(*arguments)  # type: ignore

        if autoescape:
            return Markup(rv)

        return rv  # type: ignore

    def _invoke(self, arguments: list[t.Any], autoescape: bool) -> str:
        if self._environment.is_async:
            return self._async_invoke(arguments, autoescape)  # type: ignore

        rv = self._func(*arguments)

        if autoescape:
            rv = Markup(rv)

        return rv

    def __repr__(self) -> str:
        name = "anonymous" if self.name is None else repr(self.name)
        return f"<{type(self).__name__} {name}>"


class Undefined:
    """The default undefined type. This can be printed, iterated, and treated as
    a boolean. Any other operation will raise an :exc:`UndefinedError`.

    >>> foo = Undefined(name='foo')
    >>> str(foo)
    ''
    >>> not foo
    True
    >>> foo + 42
    Traceback (most recent call last):
      ...
    jinja2.exceptions.UndefinedError: 'foo' is undefined
    """

    __slots__ = (
        "_undefined_hint",
        "_undefined_obj",
        "_undefined_name",
        "_undefined_exception",
    )

    def __init__(
        self,
        hint: str | None = None,
        obj: t.Any = missing,
        name: str | None = None,
        exc: type[TemplateRuntimeError] = UndefinedError,
    ) -> None:
        self._undefined_hint = hint
        self._undefined_obj = obj
        self._undefined_name = name
        self._undefined_exception = exc

    @property
    def _undefined_message(self) -> str:
        """Build a message about the undefined value based on how it was
        accessed.
        """
        if self._undefined_hint:
            return self._undefined_hint

        if self._undefined_obj is missing:
            return f"{self._undefined_name!r} is undefined"

        if not isinstance(self._undefined_name, str):
            return (
                f"{object_type_repr(self._undefined_obj)} has no"
                f" element {self._undefined_name!r}"
            )

        return (
            f"{object_type_repr(self._undefined_obj)!r} has no"
            f" attribute {self._undefined_name!r}"
        )

    @internalcode
    def _fail_with_undefined_error(
        self, *args: t.Any, **kwargs: t.Any
    ) -> "te.NoReturn":
        """Raise an :exc:`UndefinedError` when operations are performed
        on the undefined value.
        """
        raise self._undefined_exception(self._undefined_message)

    @internalcode
    def __getattr__(self, name: str) -> t.Any:
        # Raise AttributeError on requests for names that appear to be unimplemented
        # dunder methods to keep Python's internal protocol probing behaviors working
        # properly in cases where another exception type could cause unexpected or
        # difficult-to-diagnose failures.
        if name[:2] == "__" and name[-2:] == "__":
            raise AttributeError(name)

        return self._fail_with_undefined_error()

    __add__ = __radd__ = __sub__ = __rsub__ = _fail_with_undefined_error
    __mul__ = __rmul__ = __div__ = __rdiv__ = _fail_with_undefined_error
    __truediv__ = __rtruediv__ = _fail_with_undefined_error
    __floordiv__ = __rfloordiv__ = _fail_with_undefined_error
    __mod__ = __rmod__ = _fail_with_undefined_error
    __pos__ = __neg__ = _fail_with_undefined_error
    __call__ = __getitem__ = _fail_with_undefined_error
    __lt__ = __le__ = __gt__ = __ge__ = _fail_with_undefined_error
    __int__ = __float__ = __complex__ = _fail_with_undefined_error
    __pow__ = __rpow__ = _fail_with_undefined_error

    def __eq__(self, other: t.Any) -> bool:
        return type(self) is type(other)

    def __ne__(self, other: t.Any) -> bool:
        return not self.__eq__(other)

    def __hash__(self) -> int:
        return id(type(self))

    def __str__(self) -> str:
        return ""

    def __len__(self) -> int:
        return 0

    def __iter__(self) -> t.Iterator[t.Any]:
        yield from ()

    async def __aiter__(self) -> t.AsyncIterator[t.Any]:
        for _ in ():
            yield

    def __bool__(self) -> bool:
        return False

    def __repr__(self) -> str:
        return "Undefined"


def make_logging_undefined(
    logger: t.Optional["logging.Logger"] = None, base: type[Undefined] = Undefined
) -> type[Undefined]:
    """Given a logger object this returns a new undefined class that will
    log certain failures.  It will log iterations and printing.  If no
    logger is given a default logger is created.

    Example::

        logger = logging.getLogger(__name__)
        LoggingUndefined = make_logging_undefined(
            logger=logger,
            base=Undefined
        )

    .. versionadded:: 2.8

    :param logger: the logger to use.  If not provided, a default logger
                   is created.
    :param base: the base class to add logging functionality to.  This
                 defaults to :class:`Undefined`.
    """
    if logger is None:
        import logging

        logger = logging.getLogger(__name__)
        logger.addHandler(logging.StreamHandler(sys.stderr))

    def _log_message(undef: Undefined) -> None:
        logger.warning("Template variable warning: %s", undef._undefined_message)

    class LoggingUndefined(base):  # type: ignore
        __slots__ = ()

        def _fail_with_undefined_error(  # type: ignore
            self, *args: t.Any, **kwargs: t.Any
        ) -> "te.NoReturn":
            try:
                super()._fail_with_undefined_error(*args, **kwargs)
            except self._undefined_exception as e:
                logger.error("Template variable error: %s", e)  # type: ignore
                raise e

        def __str__(self) -> str:
            _log_message(self)
            return super().__str__()  # type: ignore

        def __iter__(self) -> t.Iterator[t.Any]:
            _log_message(self)
            return super().__iter__()  # type: ignore

        def __bool__(self) -> bool:
            _log_message(self)
            return super().__bool__()  # type: ignore

    return LoggingUndefined


class ChainableUndefined(Undefined):
    """An undefined that is chainable, where both ``__getattr__`` and
    ``__getitem__`` return itself rather than raising an
    :exc:`UndefinedError`.

    >>> foo = ChainableUndefined(name='foo')
    >>> str(foo.bar['baz'])
    ''
    >>> foo.bar['baz'] + 42
    Traceback (most recent call last):
      ...
    jinja2.exceptions.UndefinedError: 'foo' is undefined

    .. versionadded:: 2.11.0
    """

    __slots__ = ()

    def __html__(self) -> str:
        return str(self)

    def __getattr__(self, name: str) -> "ChainableUndefined":
        # Raise AttributeError on requests for names that appear to be unimplemented
        # dunder methods to avoid confusing Python with truthy non-method objects that
        # do not implement the protocol being probed for. e.g., copy.copy(Undefined())
        # fails spectacularly if getattr(Undefined(), '__setstate__') returns an
        # Undefined object instead of raising AttributeError to signal that it does not
        # support that style of object initialization.
        if name[:2] == "__" and name[-2:] == "__":
            raise AttributeError(name)

        return self

    def __getitem__(self, _name: str) -> "ChainableUndefined":  # type: ignore[override]
        return self


class DebugUndefined(Undefined):
    """An undefined that returns the debug info when printed.

    >>> foo = DebugUndefined(name='foo')
    >>> str(foo)
    '{{ foo }}'
    >>> not foo
    True
    >>> foo + 42
    Traceback (most recent call last):
      ...
    jinja2.exceptions.UndefinedError: 'foo' is undefined
    """

    __slots__ = ()

    def __str__(self) -> str:
        if self._undefined_hint:
            message = f"undefined value printed: {self._undefined_hint}"

        elif self._undefined_obj is missing:
            message = self._undefined_name  # type: ignore

        else:
            message = (
                f"no such element: {object_type_repr(self._undefined_obj)}"
                f"[{self._undefined_name!r}]"
            )

        return f"{{{{ {message} }}}}"


class StrictUndefined(Undefined):
    """An undefined that barks on print and iteration as well as boolean
    tests and all kinds of comparisons.  In other words: you can do nothing
    with it except checking if it's defined using the `defined` test.

    >>> foo = StrictUndefined(name='foo')
    >>> str(foo)
    Traceback (most recent call last):
      ...
    jinja2.exceptions.UndefinedError: 'foo' is undefined
    >>> not foo
    Traceback (most recent call last):
      ...
    jinja2.exceptions.UndefinedError: 'foo' is undefined
    >>> foo + 42
    Traceback (most recent call last):
      ...
    jinja2.exceptions.UndefinedError: 'foo' is undefined
    """

    __slots__ = ()
    __iter__ = __str__ = __len__ = Undefined._fail_with_undefined_error
    __eq__ = __ne__ = __bool__ = __hash__ = Undefined._fail_with_undefined_error
    __contains__ = Undefined._fail_with_undefined_error

import os

import click
from click.shell_completion import CompletionItem


@click.group()
def cli():
    pass


@cli.command()
@click.option("--dir", type=click.Path(file_okay=False))
def ls(dir):
    click.echo("\n".join(os.listdir(dir)))


def get_env_vars(ctx, param, incomplete):
    # Returning a list of values is a shortcut to returning a list of
    # CompletionItem(value).
    return [k for k in os.environ if incomplete in k]


@cli.command(help="A command to print environment variables")
@click.argument("envvar", shell_complete=get_env_vars)
def show_env(envvar):
    click.echo(f"Environment variable: {envvar}")
    click.echo(f"Value: {os.environ[envvar]}")


@cli.group(help="A group that holds a subcommand")
def group():
    pass


def list_users(ctx, param, incomplete):
    # You can generate completions with help strings by returning a list
    # of CompletionItem. You can match on whatever you want, including
    # the help.
    items = [("bob", "butcher"), ("alice", "baker"), ("jerry", "candlestick maker")]
    out = []

    for value, help in items:
        if incomplete in value or incomplete in help:
            out.append(CompletionItem(value, help=help))

    return out


@group.command(help="Choose a user")
@click.argument("user", shell_complete=list_users)
def select_user(user):
    click.echo(f"Chosen user is {user}")


cli.add_command(group)

"""From https://click.palletsprojects.com/en/stable/options/#yes-parameters"""

from typing_extensions import assert_type

import click


@click.command()
@click.confirmation_option(prompt="Are you sure you want to drop the db?")
def dropdb() -> None:
    click.echo("Dropped all tables!")


assert_type(dropdb, click.Command)

from __future__ import annotations

import collections.abc as cabc
from contextlib import contextmanager
from gettext import gettext as _

from ._compat import term_len
from .parser import _split_opt

# Can force a width.  This is used by the test system
FORCED_WIDTH: int | None = None


def measure_table(rows: cabc.Iterable[tuple[str, str]]) -> tuple[int, ...]:
    widths: dict[int, int] = {}

    for row in rows:
        for idx, col in enumerate(row):
            widths[idx] = max(widths.get(idx, 0), term_len(col))

    return tuple(y for x, y in sorted(widths.items()))


def iter_rows(
    rows: cabc.Iterable[tuple[str, str]], col_count: int
) -> cabc.Iterator[tuple[str, ...]]:
    for row in rows:
        yield row + ("",) * (col_count - len(row))


def wrap_text(
    text: str,
    width: int = 78,
    initial_indent: str = "",
    subsequent_indent: str = "",
    preserve_paragraphs: bool = False,
) -> str:
    """A helper function that intelligently wraps text.  By default, it
    assumes that it operates on a single paragraph of text but if the
    `preserve_paragraphs` parameter is provided it will intelligently
    handle paragraphs (defined by two empty lines).

    If paragraphs are handled, a paragraph can be prefixed with an empty
    line containing the ``\\b`` character (``\\x08``) to indicate that
    no rewrapping should happen in that block.

    :param text: the text that should be rewrapped.
    :param width: the maximum width for the text.
    :param initial_indent: the initial indent that should be placed on the
                           first line as a string.
    :param subsequent_indent: the indent string that should be placed on
                              each consecutive line.
    :param preserve_paragraphs: if this flag is set then the wrapping will
                                intelligently handle paragraphs.

    .. versionchanged:: 8.4.0
        Width is measured in visible characters. ANSI escape sequences in
        ``text``, ``initial_indent``, or ``subsequent_indent`` no longer
        count toward the width budget, so styled input wraps based on what
        the user sees instead of raw byte length.
    """
    from ._textwrap import TextWrapper

    text = text.expandtabs()
    wrapper = TextWrapper(
        width,
        initial_indent=initial_indent,
        subsequent_indent=subsequent_indent,
        replace_whitespace=False,
    )
    if not preserve_paragraphs:
        return wrapper.fill(text)

    p: list[tuple[int, bool, str]] = []
    buf: list[str] = []
    indent = None

    def _flush_par() -> None:
        if not buf:
            return
        if buf[0].strip() == "\b":
            p.append((indent or 0, True, "\n".join(buf[1:])))
        else:
            p.append((indent or 0, False, " ".join(buf)))
        del buf[:]

    for line in text.splitlines():
        if not line:
            _flush_par()
            indent = None
        else:
            if indent is None:
                orig_len = term_len(line)
                line = line.lstrip()
                indent = orig_len - term_len(line)
            buf.append(line)
    _flush_par()

    rv = []
    for indent, raw, text in p:
        with wrapper.extra_indent(" " * indent):
            if raw:
                rv.append(wrapper.indent_only(text))
            else:
                rv.append(wrapper.fill(text))

    return "\n\n".join(rv)


class HelpFormatter:
    """This class helps with formatting text-based help pages.  It's
    usually just needed for very special internal cases, but it's also
    exposed so that developers can write their own fancy outputs.

    At present, it always writes into memory.

    :param indent_increment: the additional increment for each level.
    :param width: the width for the text.  This defaults to the terminal
                  width clamped to a maximum of 78.
    """

    indent_increment: int
    width: int
    current_indent: int
    buffer: list[str]

    def __init__(
        self,
        indent_increment: int = 2,
        width: int | None = None,
        max_width: int | None = None,
    ) -> None:
        self.indent_increment = indent_increment
        if max_width is None:
            max_width = 80
        if width is None:
            import shutil

            width = FORCED_WIDTH
            if width is None:
                width = max(min(shutil.get_terminal_size().columns, max_width) - 2, 50)
        self.width = width
        self.current_indent = 0
        self.buffer = []

    def write(self, string: str) -> None:
        """Writes a unicode string into the internal buffer."""
        self.buffer.append(string)

    def indent(self) -> None:
        """Increases the indentation."""
        self.current_indent += self.indent_increment

    def dedent(self) -> None:
        """Decreases the indentation."""
        self.current_indent -= self.indent_increment

    def write_usage(self, prog: str, args: str = "", prefix: str | None = None) -> None:
        """Writes a usage line into the buffer.

        :param prog: the program name.
        :param args: whitespace separated list of arguments.
        :param prefix: The prefix for the first line. Defaults to
            ``"Usage: "``.
        """
        if prefix is None:
            prefix = "{usage} ".format(usage=_("Usage:"))

        usage_prefix = f"{prefix:>{self.current_indent}}{prog} "
        text_width = self.width - self.current_indent

        if not args:
            # Without args, the prefix's trailing space and the wrap_text
            # call that would normally place args on the line are both
            # unnecessary. Emit just the prefix line.
            self.write(usage_prefix.rstrip(" "))
            self.write("\n")
            return

        if text_width >= (term_len(usage_prefix) + 20):
            # The arguments will fit to the right of the prefix.
            indent = " " * term_len(usage_prefix)
            self.write(
                wrap_text(
                    args,
                    text_width,
                    initial_indent=usage_prefix,
                    subsequent_indent=indent,
                )
            )
        else:
            # The prefix is too long, put the arguments on the next line.
            self.write(usage_prefix)
            self.write("\n")
            indent = " " * (max(self.current_indent, term_len(prefix)) + 4)
            self.write(
                wrap_text(
                    args, text_width, initial_indent=indent, subsequent_indent=indent
                )
            )

        self.write("\n")

    def write_heading(self, heading: str) -> None:
        """Writes a heading into the buffer."""
        self.write(f"{'':>{self.current_indent}}{heading}:\n")

    def write_paragraph(self) -> None:
        """Writes a paragraph into the buffer."""
        if self.buffer:
            self.write("\n")

    def write_text(self, text: str) -> None:
        """Writes re-indented text into the buffer.  This rewraps and
        preserves paragraphs.
        """
        indent = " " * self.current_indent
        self.write(
            wrap_text(
                text,
                self.width,
                initial_indent=indent,
                subsequent_indent=indent,
                preserve_paragraphs=True,
            )
        )
        self.write("\n")

    def write_dl(
        self,
        rows: cabc.Iterable[tuple[str, str]],
        col_max: int = 30,
        col_spacing: int = 2,
    ) -> None:
        """Writes a definition list into the buffer.  This is how options
        and commands are usually formatted.

        :param rows: a list of two item tuples for the terms and values.
        :param col_max: the maximum width of the first column.
        :param col_spacing: the number of spaces between the first and
                            second column.
        """
        rows = list(rows)
        widths = measure_table(rows)
        if len(widths) != 2:
            raise TypeError("Expected two columns for definition list")

        first_col = min(widths[0], col_max) + col_spacing

        for first, second in iter_rows(rows, len(widths)):
            self.write(f"{'':>{self.current_indent}}{first}")
            if not second:
                self.write("\n")
                continue
            if term_len(first) <= first_col - col_spacing:
                self.write(" " * (first_col - term_len(first)))
            else:
                self.write("\n")
                self.write(" " * (first_col + self.current_indent))

            text_width = max(self.width - first_col - 2, 10)
            wrapped_text = wrap_text(second, text_width, preserve_paragraphs=True)
            lines = wrapped_text.splitlines()

            if lines:
                self.write(f"{lines[0]}\n")

                for line in lines[1:]:
                    self.write(f"{'':>{first_col + self.current_indent}}{line}\n")
            else:
                self.write("\n")

    @contextmanager
    def section(self, name: str) -> cabc.Generator[None]:
        """Helpful context manager that writes a paragraph, a heading,
        and the indents.

        :param name: the section name that is written as heading.
        """
        self.write_paragraph()
        self.write_heading(name)
        self.indent()
        try:
            yield
        finally:
            self.dedent()

    @contextmanager
    def indentation(self) -> cabc.Generator[None]:
        """A context manager that increases the indentation."""
        self.indent()
        try:
            yield
        finally:
            self.dedent()

    def getvalue(self) -> str:
        """Returns the buffer contents."""
        return "".join(self.buffer)


def join_options(options: cabc.Iterable[str]) -> tuple[str, bool]:
    """Given a list of option strings this joins them in the most appropriate
    way and returns them in the form ``(formatted_string,
    any_prefix_is_slash)`` where the second item in the tuple is a flag that
    indicates if any of the option prefixes was a slash.
    """
    rv = []
    any_prefix_is_slash = False

    for opt in options:
        prefix = _split_opt(opt)[0]

        if prefix == "/":
            any_prefix_is_slash = True

        rv.append((len(prefix), opt))

    rv.sort(key=lambda x: x[0])
    return ", ".join(x[1] for x in rv), any_prefix_is_slash

import sys
from io import BytesIO
from io import StringIO

import pytest

import click._termui_impl
import click.utils
from click._compat import WIN


def test_echo(runner):
    with runner.isolation() as outstreams:
        click.echo("\N{SNOWMAN}")
        click.echo(b"\x44\x44")
        click.echo(42, nl=False)
        click.echo(b"a", nl=False)
        click.echo("\x1b[31mx\x1b[39m", nl=False)
        bytes = outstreams[0].getvalue().replace(b"\r\n", b"\n")
        assert bytes == b"\xe2\x98\x83\nDD\n42ax"

    # if wrapped, we expect bytes to survive.
    @click.command()
    def cli():
        click.echo(b"\xf6")

    result = runner.invoke(cli, [])
    assert result.stdout_bytes == b"\xf6\n"

    # Ensure we do not strip for bytes.
    with runner.isolation() as outstreams:
        click.echo(bytearray(b"\x1b[31mx\x1b[39m"), nl=False)
        assert outstreams[0].getvalue() == b"\x1b[31mx\x1b[39m"


def test_echo_custom_file():
    f = StringIO()
    click.echo("hello", file=f)
    assert f.getvalue() == "hello\n"

    b = BytesIO()
    click.echo(b"", b)
    assert b.getvalue() == b"\n"


def test_echo_no_streams(monkeypatch, runner):
    """echo should not fail when stdout and stderr are None with pythonw on Windows."""
    with runner.isolation():
        sys.stdout = None
        sys.stderr = None
        click.echo("test")
        click.echo("test", err=True)


def test_echo_with_capsys(capsys):
    click.echo("Capture me.")
    out, err = capsys.readouterr()
    assert out == "Capture me.\n"


def test_echo_color_flag(monkeypatch, capfd):
    isatty = True
    monkeypatch.setattr(click._compat, "isatty", lambda x: isatty)

    text = "foo"
    styled_text = click.style(text, fg="red")
    assert styled_text == "\x1b[31mfoo\x1b[0m"

    click.echo(styled_text, color=False)
    out, err = capfd.readouterr()
    assert out == f"{text}\n"

    click.echo(styled_text, color=True)
    out, err = capfd.readouterr()
    assert out == f"{styled_text}\n"

    click.echo(styled_text)
    out, err = capfd.readouterr()
    assert out == f"{styled_text}\n"

    isatty = False
    click.echo(styled_text)
    out, err = capfd.readouterr()
    assert out == f"{text}\n"

    click.echo(styled_text, color=True)
    out, err = capfd.readouterr()
    assert out == f"{styled_text}\n"


@pytest.mark.skipif(WIN, reason="Test too complex to make work windows.")
def test_echo_writing_to_standard_error(capfd, monkeypatch):
    def emulate_input(text):
        """Emulate keyboard input."""
        monkeypatch.setattr(sys, "stdin", StringIO(text))

    click.echo("Echo to standard output")
    out, err = capfd.readouterr()
    assert out == "Echo to standard output\n"
    assert err == ""

    click.echo("Echo to standard error", err=True)
    out, err = capfd.readouterr()
    assert out == ""
    assert err == "Echo to standard error\n"

    emulate_input("asdlkj\n")
    click.prompt("Prompt to stdin")
    out, err = capfd.readouterr()
    assert out == "Prompt to stdin: "
    assert err == ""

    emulate_input("asdlkj\n")
    click.prompt("Prompt to stdin with no suffix", prompt_suffix="")
    out, err = capfd.readouterr()
    assert out == "Prompt to stdin with no suffix"
    assert err == ""

    # On non-Windows the full prompt goes through redirect_stdout so
    # nothing leaks to stdout when err=True.
    # https://github.com/pallets/click/issues/2968
    emulate_input("asdlkj\n")
    click.prompt("Prompt to stderr", err=True)
    out, err = capfd.readouterr()
    assert out == ""
    assert err == "Prompt to stderr: "

    # https://github.com/pallets/click/issues/3019
    emulate_input("asdlkj\n")
    click.prompt("Prompt to stderr with no suffix", prompt_suffix="", err=True)
    out, err = capfd.readouterr()
    assert out == ""
    assert err == "Prompt to stderr with no suffix"

    emulate_input("y\n")
    click.confirm("Prompt to stdin")
    out, err = capfd.readouterr()
    assert out == "Prompt to stdin [y/N]: "
    assert err == ""

    emulate_input("y\n")
    click.confirm("Prompt to stdin with no suffix", prompt_suffix="")
    out, err = capfd.readouterr()
    assert out == "Prompt to stdin with no suffix [y/N]"
    assert err == ""

    # https://github.com/pallets/click/issues/2968
    emulate_input("y\n")
    click.confirm("Prompt to stderr", err=True)
    out, err = capfd.readouterr()
    assert out == ""
    assert err == "Prompt to stderr [y/N]: "

    # https://github.com/pallets/click/issues/3019
    emulate_input("y\n")
    click.confirm("Prompt to stderr with no suffix", prompt_suffix="", err=True)
    out, err = capfd.readouterr()
    assert out == ""
    assert err == "Prompt to stderr with no suffix [y/N]"

    monkeypatch.setattr(click.termui, "isatty", lambda x: True)
    monkeypatch.setattr(click.termui, "getchar", lambda: " ")

    click.pause("Pause to stdout")
    out, err = capfd.readouterr()
    assert out == "Pause to stdout\n"
    assert err == ""

    click.pause("Pause to stderr", err=True)
    out, err = capfd.readouterr()
    assert out == ""
    assert err == "Pause to stderr\n"

from jinja2 import Environment
from jinja2.loaders import DictLoader

env = Environment(
    loader=DictLoader(
        {
            "a": "[A[{% block body %}{% endblock %}]]",
            "b": "{% extends 'a' %}{% block body %}[B]{% endblock %}",
            "c": "{% extends 'b' %}{% block body %}###{{ super() }}###{% endblock %}",
        }
    )
)
print(env.get_template("c").render())

import type {RetryFunction} from './options.js';

type Returns<T extends (...arguments_: any) => unknown, V> = (...arguments_: Parameters<T>) => V;

const calculateRetryDelay: Returns<RetryFunction, number> = ({
	attemptCount,
	retryOptions,
	error,
	retryAfter,
	computedValue,
}) => {
	if (error.name === 'RetryError') {
		return 1;
	}

	if (attemptCount > retryOptions.limit) {
		return 0;
	}

	const hasMethod = retryOptions.methods.includes(error.options.method);
	const hasErrorCode = retryOptions.errorCodes.includes(error.code);
	const hasStatusCode = error.response && retryOptions.statusCodes.includes(error.response.statusCode);
	if (!hasMethod || (!hasErrorCode && !hasStatusCode)) {
		return 0;
	}

	if (error.response) {
		if (retryAfter) {
			// In this case `computedValue` is `options.request.timeout`
			return retryAfter > computedValue ? 0 : retryAfter;
		}

		if (error.response.statusCode === 413) {
			return 0;
		}
	}

	const noise = Math.random() * retryOptions.noise;
	return Math.min(((2 ** (attemptCount - 1)) * 1000), retryOptions.backoffLimit) + noise;
};

export default calculateRetryDelay;

'use strict'

var after = require('after');
var express = require('../')
  , Router = express.Router
  , methods = require('../lib/utils').methods
  , assert = require('node:assert');

describe('Router', function () {
  it('should return a function with router methods', function () {
    var router = new Router();
    assert(typeof router === 'function')

    assert(typeof router.get === 'function')
    assert(typeof router.handle === 'function')
    assert(typeof router.use === 'function')
  });

  it('should support .use of other routers', function (done) {
    var router = new Router();
    var another = new Router();

    another.get('/bar', function (req, res) {
      res.end();
    });
    router.use('/foo', another);

    router.handle({ url: '/foo/bar', method: 'GET' }, { end: done }, function () { });
  });

  it('should support dynamic routes', function (done) {
    var router = new Router();
    var another = new Router();

    another.get('/:bar', function (req, res) {
      assert.strictEqual(req.params.bar, 'route')
      res.end();
    });
    router.use('/:foo', another);

    router.handle({ url: '/test/route', method: 'GET' }, { end: done }, function () { });
  });

  it('should handle blank URL', function (done) {
    var router = new Router();

    router.use(function (req, res) {
      throw new Error('should not be called')
    });

    router.handle({ url: '', method: 'GET' }, {}, done);
  });

  it('should handle missing URL', function (done) {
    var router = new Router()

    router.use(function (req, res) {
      throw new Error('should not be called')
    })

    router.handle({ method: 'GET' }, {}, done)
  })

  it('handle missing method', function (done) {
    var all = false
    var router = new Router()
    var route = router.route('/foo')
    var use = false

    route.post(function (req, res, next) { next(new Error('should not run')) })
    route.all(function (req, res, next) {
      all = true
      next()
    })
    route.get(function (req, res, next) { next(new Error('should not run')) })

    router.get('/foo', function (req, res, next) { next(new Error('should not run')) })
    router.use(function (req, res, next) {
      use = true
      next()
    })

    router.handle({ url: '/foo' }, {}, function (err) {
      if (err) return done(err)
      assert.ok(all)
      assert.ok(use)
      done()
    })
  })

  it('should not stack overflow with many registered routes', function (done) {
    this.timeout(5000) // long-running test

    var handler = function (req, res) { res.end(new Error('wrong handler')) };
    var router = new Router();

    for (var i = 0; i < 6000; i++) {
      router.get('/thing' + i, handler)
    }

    router.get('/', function (req, res) {
      res.end();
    });

    router.handle({ url: '/', method: 'GET' }, { end: done }, function () { });
  });

  it('should not stack overflow with a large sync route stack', function (done) {
    this.timeout(5000) // long-running test

    var router = new Router()

    router.get('/foo', function (req, res, next) {
      req.counter = 0
      next()
    })

    for (var i = 0; i < 6000; i++) {
      router.get('/foo', function (req, res, next) {
        req.counter++
        next()
      })
    }

    router.get('/foo', function (req, res) {
      assert.strictEqual(req.counter, 6000)
      res.end()
    })

    router.handle({ url: '/foo', method: 'GET' }, { end: done }, function (err) {
      assert(!err, err);
    });
  })

  it('should not stack overflow with a large sync middleware stack', function (done) {
    this.timeout(5000) // long-running test

    var router = new Router()

    router.use(function (req, res, next) {
      req.counter = 0
      next()
    })

    for (var i = 0; i < 6000; i++) {
      router.use(function (req, res, next) {
        req.counter++
        next()
      })
    }

    router.use(function (req, res) {
      assert.strictEqual(req.counter, 6000)
      res.end()
    })

    router.handle({ url: '/', method: 'GET' }, { end: done }, function (err) {
      assert(!err, err);
    })
  })

  describe('.handle', function () {
    it('should dispatch', function (done) {
      var router = new Router();

      router.route('/foo').get(function (req, res) {
        res.send('foo');
      });

      var res = {
        send: function (val) {
          assert.strictEqual(val, 'foo')
          done();
        }
      }
      router.handle({ url: '/foo', method: 'GET' }, res, function () { });
    })
  })

  describe('.multiple callbacks', function () {
    it('should throw if a callback is null', function () {
      assert.throws(function () {
        var router = new Router();
        router.route('/foo').all(null);
      })
    })

    it('should throw if a callback is undefined', function () {
      assert.throws(function () {
        var router = new Router();
        router.route('/foo').all(undefined);
      })
    })

    it('should throw if a callback is not a function', function () {
      assert.throws(function () {
        var router = new Router();
        router.route('/foo').all('not a function');
      })
    })

    it('should not throw if all callbacks are functions', function () {
      var router = new Router();
      router.route('/foo').all(function () { }).all(function () { });
    })
  })

  describe('error', function () {
    it('should skip non error middleware', function (done) {
      var router = new Router();

      router.get('/foo', function (req, res, next) {
        next(new Error('foo'));
      });

      router.get('/bar', function (req, res, next) {
        next(new Error('bar'));
      });

      router.use(function (req, res, next) {
        assert(false);
      });

      router.use(function (err, req, res, next) {
        assert.equal(err.message, 'foo');
        done();
      });

      router.handle({ url: '/foo', method: 'GET' }, {}, done);
    });

    it('should handle throwing inside routes with params', function (done) {
      var router = new Router();

      router.get('/foo/:id', function () {
        throw new Error('foo');
      });

      router.use(function (req, res, next) {
        assert(false);
      });

      router.use(function (err, req, res, next) {
        assert.equal(err.message, 'foo');
        done();
      });

      router.handle({ url: '/foo/2', method: 'GET' }, {}, function () { });
    });

    it('should handle throwing in handler after async param', function (done) {
      var router = new Router();

      router.param('user', function (req, res, next, val) {
        process.nextTick(function () {
          req.user = val;
          next();
        });
      });

      router.use('/:user', function (req, res, next) {
        throw new Error('oh no!');
      });

      router.use(function (err, req, res, next) {
        assert.equal(err.message, 'oh no!');
        done();
      });

      router.handle({ url: '/bob', method: 'GET' }, {}, function () { });
    });

    it('should handle throwing inside error handlers', function (done) {
      var router = new Router();

      router.use(function (req, res, next) {
        throw new Error('boom!');
      });

      router.use(function (err, req, res, next) {
        throw new Error('oops');
      });

      router.use(function (err, req, res, next) {
        assert.equal(err.message, 'oops');
        done();
      });

      router.handle({ url: '/', method: 'GET' }, {}, done);
    });
  })

  describe('FQDN', function () {
    it('should not obscure FQDNs', function (done) {
      var request = { hit: 0, url: 'http://example.com/foo', method: 'GET' };
      var router = new Router();

      router.use(function (req, res, next) {
        assert.equal(req.hit++, 0);
        assert.equal(req.url, 'http://example.com/foo');
        next();
      });

      router.handle(request, {}, function (err) {
        if (err) return done(err);
        assert.equal(request.hit, 1);
        done();
      });
    });

    it('should ignore FQDN in search', function (done) {
      var request = { hit: 0, url: '/proxy?url=http://example.com/blog/post/1', method: 'GET' };
      var router = new Router();

      router.use('/proxy', function (req, res, next) {
        assert.equal(req.hit++, 0);
        assert.equal(req.url, '/?url=http://example.com/blog/post/1');
        next();
      });

      router.handle(request, {}, function (err) {
        if (err) return done(err);
        assert.equal(request.hit, 1);
        done();
      });
    });

    it('should ignore FQDN in path', function (done) {
      var request = { hit: 0, url: '/proxy/http://example.com/blog/post/1', method: 'GET' };
      var router = new Router();

      router.use('/proxy', function (req, res, next) {
        assert.equal(req.hit++, 0);
        assert.equal(req.url, '/http://example.com/blog/post/1');
        next();
      });

      router.handle(request, {}, function (err) {
        if (err) return done(err);
        assert.equal(request.hit, 1);
        done();
      });
    });

    it('should adjust FQDN req.url', function (done) {
      var request = { hit: 0, url: 'http://example.com/blog/post/1', method: 'GET' };
      var router = new Router();

      router.use('/blog', function (req, res, next) {
        assert.equal(req.hit++, 0);
        assert.equal(req.url, 'http://example.com/post/1');
        next();
      });

      router.handle(request, {}, function (err) {
        if (err) return done(err);
        assert.equal(request.hit, 1);
        done();
      });
    });

    it('should adjust FQDN req.url with multiple handlers', function (done) {
      var request = { hit: 0, url: 'http://example.com/blog/post/1', method: 'GET' };
      var router = new Router();

      router.use(function (req, res, next) {
        assert.equal(req.hit++, 0);
        assert.equal(req.url, 'http://example.com/blog/post/1');
        next();
      });

      router.use('/blog', function (req, res, next) {
        assert.equal(req.hit++, 1);
        assert.equal(req.url, 'http://example.com/post/1');
        next();
      });

      router.handle(request, {}, function (err) {
        if (err) return done(err);
        assert.equal(request.hit, 2);
        done();
      });
    });

    it('should adjust FQDN req.url with multiple routed handlers', function (done) {
      var request = { hit: 0, url: 'http://example.com/blog/post/1', method: 'GET' };
      var router = new Router();

      router.use('/blog', function (req, res, next) {
        assert.equal(req.hit++, 0);
        assert.equal(req.url, 'http://example.com/post/1');
        next();
      });

      router.use('/blog', function (req, res, next) {
        assert.equal(req.hit++, 1);
        assert.equal(req.url, 'http://example.com/post/1');
        next();
      });

      router.use(function (req, res, next) {
        assert.equal(req.hit++, 2);
        assert.equal(req.url, 'http://example.com/blog/post/1');
        next();
      });

      router.handle(request, {}, function (err) {
        if (err) return done(err);
        assert.equal(request.hit, 3);
        done();
      });
    });
  })

  describe('.all', function () {
    it('should support using .all to capture all http verbs', function (done) {
      var router = new Router();

      var count = 0;
      router.all('/foo', function () { count++; });

      var url = '/foo?bar=baz';

      methods.forEach(function testMethod(method) {
        router.handle({ url: url, method: method }, {}, function () { });
      });

      assert.equal(count, methods.length);
      done();
    })
  })

  describe('.use', function () {
    it('should require middleware', function () {
      var router = new Router()
      assert.throws(function () { router.use('/') }, /argument handler is required/)
    })

    it('should reject string as middleware', function () {
      var router = new Router()
      assert.throws(function () { router.use('/', 'foo') }, /argument handler must be a function/)
    })

    it('should reject number as middleware', function () {
      var router = new Router()
      assert.throws(function () { router.use('/', 42) }, /argument handler must be a function/)
    })

    it('should reject null as middleware', function () {
      var router = new Router()
      assert.throws(function () { router.use('/', null) }, /argument handler must be a function/)
    })

    it('should reject Date as middleware', function () {
      var router = new Router()
      assert.throws(function () { router.use('/', new Date()) }, /argument handler must be a function/)
    })

    it('should be called for any URL', function (done) {
      var cb = after(4, done)
      var router = new Router()

      function no() {
        throw new Error('should not be called')
      }

      router.use(function (req, res) {
        res.end()
      })

      router.handle({ url: '/', method: 'GET' }, { end: cb }, no)
      router.handle({ url: '/foo', method: 'GET' }, { end: cb }, no)
      router.handle({ url: 'foo', method: 'GET' }, { end: cb }, no)
      router.handle({ url: '*', method: 'GET' }, { end: cb }, no)
    })

    it('should accept array of middleware', function (done) {
      var count = 0;
      var router = new Router();

      function fn1(req, res, next) {
        assert.equal(++count, 1);
        next();
      }

      function fn2(req, res, next) {
        assert.equal(++count, 2);
        next();
      }

      router.use([fn1, fn2], function (req, res) {
        assert.equal(++count, 3);
        done();
      });

      router.handle({ url: '/foo', method: 'GET' }, {}, function () { });
    })
  })

  describe('.param', function () {
    it('should require function', function () {
      var router = new Router();
      assert.throws(router.param.bind(router, 'id'), /argument fn is required/);
    });

    it('should reject non-function', function () {
      var router = new Router();
      assert.throws(router.param.bind(router, 'id', 42), /argument fn must be a function/);
    });

    it('should call param function when routing VERBS', function (done) {
      var router = new Router();

      router.param('id', function (req, res, next, id) {
        assert.equal(id, '123');
        next();
      });

      router.get('/foo/:id/bar', function (req, res, next) {
        assert.equal(req.params.id, '123');
        next();
      });

      router.handle({ url: '/foo/123/bar', method: 'get' }, {}, done);
    });

    it('should call param function when routing middleware', function (done) {
      var router = new Router();

      router.param('id', function (req, res, next, id) {
        assert.equal(id, '123');
        next();
      });

      router.use('/foo/:id/bar', function (req, res, next) {
        assert.equal(req.params.id, '123');
        assert.equal(req.url, '/baz');
        next();
      });

      router.handle({ url: '/foo/123/bar/baz', method: 'get' }, {}, done);
    });

    it('should only call once per request', function (done) {
      var count = 0;
      var req = { url: '/foo/bob/bar', method: 'get' };
      var router = new Router();
      var sub = new Router();

      sub.get('/bar', function (req, res, next) {
        next();
      });

      router.param('user', function (req, res, next, user) {
        count++;
        req.user = user;
        next();
      });

      router.use('/foo/:user/', new Router());
      router.use('/foo/:user/', sub);

      router.handle(req, {}, function (err) {
        if (err) return done(err);
        assert.equal(count, 1);
        assert.equal(req.user, 'bob');
        done();
      });
    });

    it('should call when values differ', function (done) {
      var count = 0;
      var req = { url: '/foo/bob/bar', method: 'get' };
      var router = new Router();
      var sub = new Router();

      sub.get('/bar', function (req, res, next) {
        next();
      });

      router.param('user', function (req, res, next, user) {
        count++;
        req.user = user;
        next();
      });

      router.use('/foo/:user/', new Router());
      router.use('/:user/bob/', sub);

      router.handle(req, {}, function (err) {
        if (err) return done(err);
        assert.equal(count, 2);
        assert.equal(req.user, 'foo');
        done();
      });
    });
  });

  describe('parallel requests', function () {
    it('should not mix requests', function (done) {
      var req1 = { url: '/foo/50/bar', method: 'get' };
      var req2 = { url: '/foo/10/bar', method: 'get' };
      var router = new Router();
      var sub = new Router();
      var cb = after(2, done)


      sub.get('/bar', function (req, res, next) {
        next();
      });

      router.param('ms', function (req, res, next, ms) {
        ms = parseInt(ms, 10);
        req.ms = ms;
        setTimeout(next, ms);
      });

      router.use('/foo/:ms/', new Router());
      router.use('/foo/:ms/', sub);

      router.handle(req1, {}, function (err) {
        assert.ifError(err);
        assert.equal(req1.ms, 50);
        assert.equal(req1.originalUrl, '/foo/50/bar');
        cb()
      });

      router.handle(req2, {}, function (err) {
        assert.ifError(err);
        assert.equal(req2.ms, 10);
        assert.equal(req2.originalUrl, '/foo/10/bar');
        cb()
      });
    });
  });
})

import type {AddressInfo} from 'node:net';
import https from 'node:https';
// @ts-expect-error No types
import createCert from 'create-cert';

const keys = await createCert({days: 365, commonName: 'localhost'});

const server = https.createServer(keys, (_request, response) => {
	response.end('ok');
}).listen(8080, () => {
	const {port} = server.address() as AddressInfo;
	console.log(`Listening at https://localhost:${port}`);
});

import test from 'ava';
import withServer from './helpers/with-server.js';

test('does not decompress 304 Not Modified responses with content-encoding header', withServer, async (t, server, got) => {
	server.get('/', (_request, response) => {
		response.writeHead(304, {
			'content-encoding': 'gzip',
		});
		response.end();
	});

	// Should not hang even though the response has content-encoding header but no body
	const response = await got({
		throwHttpErrors: false,
		timeout: {
			request: 1000, // 1 second timeout to catch hangs
		},
	});

	t.is(response.statusCode, 304);
	t.is(response.body, '');
});

test('does not decompress 204 No Content responses with content-encoding header', withServer, async (t, server, got) => {
	server.get('/', (_request, response) => {
		response.writeHead(204, {
			'content-encoding': 'gzip',
		});
		response.end();
	});

	const response = await got({
		throwHttpErrors: false,
		timeout: {
			request: 1000,
		},
	});

	t.is(response.statusCode, 204);
	t.is(response.body, '');
});

test('does not decompress 205 Reset Content responses with content-encoding header', withServer, async (t, server, got) => {
	server.get('/', (_request, response) => {
		response.writeHead(205, {
			'content-encoding': 'gzip',
		});
		response.end();
	});

	const response = await got({
		throwHttpErrors: false,
		timeout: {
			request: 1000,
		},
	});

	t.is(response.statusCode, 205);
	t.is(response.body, '');
});

test('does not decompress HEAD responses with content-encoding header', withServer, async (t, server, got) => {
	server.get('/', (_request, response) => {
		// HEAD responses should never have a body, regardless of status code
		response.writeHead(200, {
			'content-encoding': 'gzip',
			'content-type': 'text/plain',
			'content-length': '11', // Would be the length if it had a body
		});
		response.end();
	});

	const response = await got.head({
		throwHttpErrors: false,
		timeout: {
			request: 1000,
		},
	});

	t.is(response.statusCode, 200);
	t.is(response.body, '');
});

// Note: 1xx responses are handled specially by Node.js and typically
// don't reach user code in the same way as other status codes

# The builds in this file are more complex (e.g. they need custom CMake
# configuration) and thus are unsuitable to the simple build matrix
# approach used in simple-builds
name: Linux Builds (Complex)

on: [push, pull_request]

env:
  CTEST_OUTPUT_ON_FAILURE: 1
  CTEST_NO_TESTS_ACTION: error

jobs:
  build:
    name: ${{matrix.build_description}}, ${{matrix.cxx}}, C++${{matrix.std}} ${{matrix.build_type}}
    runs-on: ubuntu-22.04
    strategy:
      fail-fast: false
      matrix:
        # We add builds one by one in this case, because there are no
        # dimensions that are shared across the builds
        include:

          # Single surrogate header build
          - cxx: clang++-14
            build_description: Surrogates build
            build_type: Debug
            std: 14
            other_pkgs: clang-14
            cmake_configurations: -DCATCH_BUILD_SURROGATES=ON

          # Extras and examples with gcc-11
          - cxx: g++-11
            build_description: Extras + Examples
            build_type: Debug
            std: 14
            other_pkgs: g++-11
            cmake_configurations: -DCATCH_BUILD_EXTRA_TESTS=ON -DCATCH_BUILD_EXAMPLES=ON -DCATCH_ENABLE_CMAKE_HELPER_TESTS=ON
          - cxx: g++-11
            build_description: Extras + Examples
            build_type: Release
            std: 14
            other_pkgs: g++-11
            cmake_configurations: -DCATCH_BUILD_EXTRA_TESTS=ON -DCATCH_BUILD_EXAMPLES=ON -DCATCH_ENABLE_CMAKE_HELPER_TESTS=ON

          # Extras and examples with Clang-14
          - cxx: clang++-14
            build_description: Extras + Examples
            build_type: Debug
            std: 17
            other_pkgs: clang-14
            cmake_configurations: -DCATCH_BUILD_EXTRA_TESTS=ON -DCATCH_BUILD_EXAMPLES=ON -DCATCH_ENABLE_CMAKE_HELPER_TESTS=ON
          - cxx: clang++-14
            build_description: Extras + Examples
            build_type: Release
            std: 17
            other_pkgs: clang-14
            cmake_configurations: -DCATCH_BUILD_EXTRA_TESTS=ON -DCATCH_BUILD_EXAMPLES=ON -DCATCH_ENABLE_CMAKE_HELPER_TESTS=ON

          # Configure tests with Clang-14
          - cxx: clang++-14
            build_description: CMake configuration tests
            build_type: Debug
            std: 14
            other_pkgs: clang-14
            cmake_configurations: -DCATCH_ENABLE_CONFIGURE_TESTS=ON

          # Valgrind test Clang-14
          # - cxx: clang++-14
          #   build_description: Valgrind tests
          #   build_type: Debug
          #   std: 14
          #   other_pkgs: clang-14 valgrind
          #   cmake_configurations: -DMEMORYCHECK_COMMAND=`which valgrind` -DMEMORYCHECK_COMMAND_OPTIONS="-q --track-origins=yes --leak-check=full --num-callers=50 --show-leak-kinds=definite --error-exitcode=1"
          #   other_ctest_args: -T memcheck -LE uses-python


    steps:
    - uses: actions/checkout@v6

    - name: Prepare environment
      run: |
        sudo apt-get update
        sudo apt-get install -y ninja-build ${{matrix.other_pkgs}}

    - name: Configure build
      run: |
        cmake --preset basic-tests -GNinja \
              -DCMAKE_BUILD_TYPE=${{matrix.build_type}} \
              -DCMAKE_CXX_COMPILER=${{matrix.cxx}} \
              -DCMAKE_CXX_STANDARD=${{matrix.std}} \
              ${{matrix.cmake_configurations}}

    - name: Build
      run: cmake --build build

    - name: Test
      run: ctest --test-dir build -j

  clang-tidy:
    name: clang-tidy
    runs-on: ubuntu-22.04
    steps:
    - uses: actions/checkout@v6

    - name: Prepare environment
      run: |
        sudo apt-get update
        sudo apt-get install -y ninja-build clang-15 clang-tidy-15

    - name: Configure
      run: |
        clangtidy="clang-tidy-15;-use-color"
        # Use a dummy compiler/linker/ar/ranlib to effectively disable the
        # compilation and only run clang-tidy.
        cmake --preset basic-tests -GNinja \
              -DCMAKE_AR=/usr/bin/true \
              -DCMAKE_BUILD_TYPE=Debug \
              -DCMAKE_CXX_CLANG_TIDY="$clangtidy" \
              -DCMAKE_CXX_COMPILER_AR=/usr/bin/true \
              -DCMAKE_CXX_COMPILER_LAUNCHER=/usr/bin/true \
              -DCMAKE_CXX_COMPILER=clang++-15 \
              -DCMAKE_CXX_LINK_EXECUTABLE=/usr/bin/true \
              -DCMAKE_CXX_STANDARD=17 \
              -DCMAKE_RANLIB=/usr/bin/true \
              -DCATCH_BUILD_EXAMPLES=ON \
              -DCATCH_ENABLE_CMAKE_HELPER_TESTS=ON

    - name: Run clang-tidy
      run: cmake --build build

"""Built-in template tests used with the ``is`` operator."""

import operator
import typing as t
from collections import abc
from numbers import Number

from .runtime import Undefined
from .utils import pass_environment

if t.TYPE_CHECKING:
    from .environment import Environment


def test_odd(value: int) -> bool:
    """Return true if the variable is odd."""
    return value % 2 == 1


def test_even(value: int) -> bool:
    """Return true if the variable is even."""
    return value % 2 == 0


def test_divisibleby(value: int, num: int) -> bool:
    """Check if a variable is divisible by a number."""
    return value % num == 0


def test_defined(value: t.Any) -> bool:
    """Return true if the variable is defined:

    .. sourcecode:: jinja

        {% if variable is defined %}
            value of variable: {{ variable }}
        {% else %}
            variable is not defined
        {% endif %}

    See the :func:`default` filter for a simple way to set undefined
    variables.
    """
    return not isinstance(value, Undefined)


def test_undefined(value: t.Any) -> bool:
    """Like :func:`defined` but the other way round."""
    return isinstance(value, Undefined)


@pass_environment
def test_filter(env: "Environment", value: str) -> bool:
    """Check if a filter exists by name. Useful if a filter may be
    optionally available.

    .. code-block:: jinja

        {% if 'markdown' is filter %}
            {{ value | markdown }}
        {% else %}
            {{ value }}
        {% endif %}

    .. versionadded:: 3.0
    """
    return value in env.filters


@pass_environment
def test_test(env: "Environment", value: str) -> bool:
    """Check if a test exists by name. Useful if a test may be
    optionally available.

    .. code-block:: jinja

        {% if 'loud' is test %}
            {% if value is loud %}
                {{ value|upper }}
            {% else %}
                {{ value|lower }}
            {% endif %}
        {% else %}
            {{ value }}
        {% endif %}

    .. versionadded:: 3.0
    """
    return value in env.tests


def test_none(value: t.Any) -> bool:
    """Return true if the variable is none."""
    return value is None


def test_boolean(value: t.Any) -> bool:
    """Return true if the object is a boolean value.

    .. versionadded:: 2.11
    """
    return value is True or value is False


def test_false(value: t.Any) -> bool:
    """Return true if the object is False.

    .. versionadded:: 2.11
    """
    return value is False


def test_true(value: t.Any) -> bool:
    """Return true if the object is True.

    .. versionadded:: 2.11
    """
    return value is True


# NOTE: The existing 'number' test matches booleans and floats
def test_integer(value: t.Any) -> bool:
    """Return true if the object is an integer.

    .. versionadded:: 2.11
    """
    return isinstance(value, int) and value is not True and value is not False


# NOTE: The existing 'number' test matches booleans and integers
def test_float(value: t.Any) -> bool:
    """Return true if the object is a float.

    .. versionadded:: 2.11
    """
    return isinstance(value, float)


def test_lower(value: str) -> bool:
    """Return true if the variable is lowercased."""
    return str(value).islower()


def test_upper(value: str) -> bool:
    """Return true if the variable is uppercased."""
    return str(value).isupper()


def test_string(value: t.Any) -> bool:
    """Return true if the object is a string."""
    return isinstance(value, str)


def test_mapping(value: t.Any) -> bool:
    """Return true if the object is a mapping (dict etc.).

    .. versionadded:: 2.6
    """
    return isinstance(value, abc.Mapping)


def test_number(value: t.Any) -> bool:
    """Return true if the variable is a number."""
    return isinstance(value, Number)


def test_sequence(value: t.Any) -> bool:
    """Return true if the variable is a sequence. Sequences are variables
    that are iterable.
    """
    try:
        len(value)
        value.__getitem__  # noqa B018
    except Exception:
        return False

    return True


def test_sameas(value: t.Any, other: t.Any) -> bool:
    """Check if an object points to the same memory address than another
    object:

    .. sourcecode:: jinja

        {% if foo.attribute is sameas false %}
            the foo attribute really is the `False` singleton
        {% endif %}
    """
    return value is other


def test_iterable(value: t.Any) -> bool:
    """Check if it's possible to iterate over an object."""
    try:
        iter(value)
    except TypeError:
        return False

    return True


def test_escaped(value: t.Any) -> bool:
    """Check if the value is escaped."""
    return hasattr(value, "__html__")


def test_in(value: t.Any, seq: t.Container[t.Any]) -> bool:
    """Check if value is in seq.

    .. versionadded:: 2.10
    """
    return value in seq


TESTS = {
    "odd": test_odd,
    "even": test_even,
    "divisibleby": test_divisibleby,
    "defined": test_defined,
    "undefined": test_undefined,
    "filter": test_filter,
    "test": test_test,
    "none": test_none,
    "boolean": test_boolean,
    "false": test_false,
    "true": test_true,
    "integer": test_integer,
    "float": test_float,
    "lower": test_lower,
    "upper": test_upper,
    "string": test_string,
    "mapping": test_mapping,
    "number": test_number,
    "sequence": test_sequence,
    "iterable": test_iterable,
    "callable": callable,
    "sameas": test_sameas,
    "escaped": test_escaped,
    "in": test_in,
    "==": operator.eq,
    "eq": operator.eq,
    "equalto": operator.eq,
    "!=": operator.ne,
    "ne": operator.ne,
    ">": operator.gt,
    "gt": operator.gt,
    "greaterthan": operator.gt,
    "ge": operator.ge,
    ">=": operator.ge,
    "<": operator.lt,
    "lt": operator.lt,
    "lessthan": operator.lt,
    "<=": operator.le,
    "le": operator.le,
}

import test from 'ava';
import withServer from './helpers/with-server.js';

// Test for issue #2414: Endless recurrent loop upon retry in options.js
// https://github.com/sindresorhus/got/issues/2414
test('does not cause infinite loop when retrying with request.options', withServer, async (t, server, got) => {
	server.get('/', (_request, response) => {
		response.statusCode = 401;
		response.end();
	});

	let isCalled = false;

	await got({
		hooks: {
			afterResponse: [
				(response, retry) => {
					if (!isCalled) {
						isCalled = true;
						// This used to cause an infinite loop in versions 12-14
						return retry(response.request.options);
					}

					return response;
				},
			],
		},
		throwHttpErrors: false,
		retry: {
			limit: 0,
		},
	});

	t.true(isCalled);
});

version: 2
# Do not specify sphinx key here to be in full control of build steps.
# https://docs.readthedocs.com/platform/stable/build-customization.html#extend-or-override-the-build-process

build:
  os: ubuntu-24.04
  tools:
    python: '3.13'
  jobs:
    install:
      - echo "Installing dependencies"
      - asdf plugin add uv
      - asdf install uv latest
      - asdf global uv latest
    build:
      html:
        - uv run --group docs sphinx-build -W -b dirhtml docs $READTHEDOCS_OUTPUT/html

import {setImmediate} from 'node:timers/promises';
import type {LookupFunction} from 'node:net';
import test from 'ava';
import DnsCache from '../source/core/utils/dns-cache.js';

const createDnsError = (code: string) => {
	const error = new Error(code) as NodeJS.ErrnoException;
	error.code = code;
	return error;
};

test('DNS cache fallback state is scoped to lookup options', async t => {
	let lookupCallCount = 0;
	let resolve4CallCount = 0;
	let resolve6CallCount = 0;
	const cache = new DnsCache({
		fallbackDuration: 60,
		lookup: ((_hostname: string, options: any, callback: any) => {
			lookupCallCount++;

			if (options.family === 6) {
				callback(new Error('Unexpected IPv6 fallback lookup'));
				return;
			}

			callback(null, [{address: '127.0.0.1', family: 4}]);
		}) as LookupFunction,
		resolver: {
			async resolve4() {
				resolve4CallCount++;
				throw createDnsError('ENODATA');
			},
			async resolve6() {
				resolve6CallCount++;
				return [{address: '::1', ttl: 60}];
			},
		},
	});

	t.deepEqual(await cache.lookupAsync('example.com', {family: 4}), {
		address: '127.0.0.1',
		family: 4,
	});
	t.deepEqual(await cache.lookupAsync('example.com', {family: 6}), {
		address: '::1',
		family: 6,
	});
	t.is(resolve4CallCount, 1);
	t.is(resolve6CallCount, 1);
	t.is(lookupCallCount, 1);
});

test('DNS cache clears fallback state for all hostnames', async t => {
	let lookupCallCount = 0;
	let resolve4CallCount = 0;
	const cache = new DnsCache({
		fallbackDuration: 60,
		lookup: ((_hostname: string, _options: any, callback: any) => {
			lookupCallCount++;
			callback(null, [{address: '127.0.0.1', family: 4}]);
		}) as LookupFunction,
		resolver: {
			async resolve4() {
				resolve4CallCount++;
				throw createDnsError('ENOTFOUND');
			},
			async resolve6() {
				return [];
			},
		},
	});

	await cache.lookupAsync('example.com', {family: 4});
	await cache.lookupAsync('example.com', {family: 4});
	cache.clear();
	await cache.lookupAsync('example.com', {family: 4});

	t.is(resolve4CallCount, 2);
	t.is(lookupCallCount, 3);
});

test('DNS cache clears missing fallback state for all hostnames', async t => {
	let lookupCallCount = 0;
	const cache = new DnsCache({
		lookup: ((_hostname: string, _options: any, callback: any) => {
			lookupCallCount++;
			callback(createDnsError('ENOTFOUND'));
		}) as LookupFunction,
		resolver: {
			async resolve4() {
				throw createDnsError('ENOTFOUND');
			},
			async resolve6() {
				return [];
			},
		},
	});

	await t.throwsAsync(cache.lookupAsync('example.com', {family: 4}), {
		message: 'DNS cache lookup ENOTFOUND example.com',
	});
	await t.throwsAsync(cache.lookupAsync('example.com', {family: 4}), {
		message: 'DNS cache lookup ENOTFOUND example.com',
	});
	cache.clear();
	await t.throwsAsync(cache.lookupAsync('example.com', {family: 4}), {
		message: 'DNS cache lookup ENOTFOUND example.com',
	});

	t.is(lookupCallCount, 2);
});

test('DNS cache does not cache fallback state cleared by clearing all hostnames', async t => {
	let resolveLookup!: () => void;
	let lookupCallCount = 0;
	let resolve4CallCount = 0;
	const cache = new DnsCache({
		fallbackDuration: 60,
		lookup: ((_hostname: string, _options: any, callback: any) => {
			lookupCallCount++;

			void (async () => {
				await new Promise<void>(resolve => {
					resolveLookup = resolve;
				});

				callback(null, [{address: '127.0.0.1', family: 4}]);
			})();
		}) as LookupFunction,
		resolver: {
			async resolve4() {
				resolve4CallCount++;
				throw createDnsError('ENOTFOUND');
			},
			async resolve6() {
				return [];
			},
		},
	});

	const lookup = cache.lookupAsync('example.com', {family: 4});
	await setImmediate();
	cache.clear();
	resolveLookup();

	t.like(await lookup, {address: '127.0.0.1'});

	const secondLookup = cache.lookupAsync('example.com', {family: 4});
	await setImmediate();
	resolveLookup();

	t.like(await secondLookup, {address: '127.0.0.1'});
	t.is(resolve4CallCount, 2);
	t.is(lookupCallCount, 2);
});

{
    "version": 3,
    "configurePresets": [
        {
            "name": "basic-tests",
            "binaryDir": "build",
            "installDir": "build/install",
            "displayName": "Basic development build",
            "description": "Enables development build with basic tests that are cheap to build and run",
            "cacheVariables": {
                "CMAKE_CXX_EXTENSIONS": "OFF",
                "CMAKE_CXX_STANDARD_REQUIRED": "ON",
                "CMAKE_EXPORT_COMPILE_COMMANDS": "ON",
                "CATCH_DEVELOPMENT_BUILD": "ON"
            }
        },
        {
            "name": "most-tests",
            "inherits": "basic-tests",
            "displayName": "Full development build",
            "description": "Enables development build with extended set of tests (still relatively cheap to build)",
            "cacheVariables": {
                "CATCH_BUILD_EXAMPLES": "ON",
                "CATCH_BUILD_EXTRA_TESTS": "ON",
                "CATCH_BUILD_SURROGATES": "ON",
                "CATCH_BUILD_BENCHMARKS": "ON"
            }
        },
        {
            "name": "all-tests",
            "inherits": "most-tests",
            "displayName": "Full development build",
            "description": "Enables development build with examples and ALL tests",
            "cacheVariables": {
                "CATCH_ENABLE_CONFIGURE_TESTS": "ON",
                "CATCH_ENABLE_CMAKE_HELPER_TESTS": "ON"
            }
        }
    ]   
}

import type {EventEmitter} from 'node:events';

export default function proxyEvents(from: EventEmitter, to: EventEmitter, events: readonly string[]): () => void {
	const eventFunctions = new Map<string, (...arguments_: unknown[]) => void>();

	for (const event of events) {
		const eventFunction = (...arguments_: unknown[]) => {
			to.emit(event, ...arguments_);
		};

		eventFunctions.set(event, eventFunction);
		from.on(event, eventFunction);
	}

	return () => {
		for (const [event, eventFunction] of eventFunctions) {
			from.off(event, eventFunction);
		}
	};
}

[project]
name = "click"
version = "8.5.0.dev"
description = "Composable command line interface toolkit"
readme = "README.md"
license = "BSD-3-Clause"
license-files = ["LICENSE.txt"]
maintainers = [{name = "Pallets", email = "contact@palletsprojects.com"}]
classifiers = [
    "Development Status :: 5 - Production/Stable",
    "Intended Audience :: Developers",
    "Operating System :: OS Independent",
    "Programming Language :: Python",
    "Typing :: Typed",
]
requires-python = ">=3.10"

[project.urls]
Donate = "https://palletsprojects.com/donate"
Documentation = "https://click.palletsprojects.com/"
Changes = "https://click.palletsprojects.com/page/changes/"
Source = "https://github.com/pallets/click/"
Chat = "https://discord.gg/pallets"

[dependency-groups]
dev = [
    "ruff",
    "tox",
    "tox-uv",
]
docs = [
    "myst-parser",
    "pallets-sphinx-themes",
    "sphinx",
    "sphinx-tabs",
    "sphinxcontrib-log-cabinet",
]
docs-auto = [
    "sphinx-autobuild",
]
gha-update = [
    "gha-update ; python_full_version >= '3.12'",
]
pre-commit = [
    "pre-commit",
    "pre-commit-uv",
]
tests = [
    "pytest",
]
tests-random = [
    "pytest",
    "pytest-randomly",
    "pytest-xdist",
]
typing = [
    "mypy",
    "pyright",
    "pytest",
]

[build-system]
requires = ["flit_core>=3.11,<4"]
build-backend = "flit_core.buildapi"

[tool.flit.module]
name = "click"

[tool.flit.sdist]
include = [
    "docs/",
    "tests/",
    "CHANGES.md",
    "uv.lock"
]
exclude = [
    "docs/_build/",
]

[tool.uv]
default-groups = ["dev", "pre-commit", "tests", "typing"]

[tool.pytest.ini_options]
testpaths = ["tests"]
filterwarnings = [
    "error",
]
markers = [
    "stress: high-iteration stress tests for race conditions (deselect with '-m \"not stress\"')",
]
addopts = "-m 'not stress'"

[tool.coverage.run]
branch = true
source = ["click", "tests"]

[tool.coverage.paths]
source = ["src", "*/site-packages"]

[tool.coverage.report]
exclude_also = [
    "if t.TYPE_CHECKING",
    "raise NotImplementedError",
    ": \\.{3}",
]

[tool.mypy]
python_version = "3.10"
files = ["src", "tests/typing"]
show_error_codes = true
pretty = true
strict = true

[tool.pyright]
pythonVersion = "3.10"
include = ["src", "tests/typing"]
typeCheckingMode = "basic"

[tool.ruff]
extend-exclude = ["examples/"]
src = ["src"]
fix = true
show-fixes = true
output-format = "full"

[tool.ruff.lint]
select = [
    "B",  # flake8-bugbear
    "E",  # pycodestyle error
    "F",  # pyflakes
    "I",  # isort
    "UP",  # pyupgrade
    "W",  # pycodestyle warning
    "ICN", #flake8-import-conventions (ICN)
]

[tool.ruff.lint.flake8-import-conventions.aliases]
# Declare the default aliases.
typing = "t"

[tool.ruff.lint.isort]
force-single-line = true
order-by-type = false

[tool.tox]
env_list = [
    "py3.14", "py3.13", "py3.12", "py3.11", "py3.10",
    "py3.14t",
    "pypy3.11",
    "stress-py3.14", "stress-py3.14t",
    "style",
    "typing",
    "docs",
]

[tool.tox.env_run_base]
description = "pytest on latest dependency versions"
runner = "uv-venv-lock-runner"
package = "wheel"
wheel_build_env = ".pkg"
constrain_package_deps = true
use_frozen_constraints = true
dependency_groups = ["tests"]
commands = [[
    "pytest", "-v", "--tb=short", "--basetemp={env_tmp_dir}",
    {replace = "posargs", default = [], extend = true},
]]

[tool.tox.env.random]
description = "randomized parallel tests to detect test pollution and race conditions"
dependency_groups = ["tests-random"]
commands = [[
    "pytest", "-v", "--tb=short", "--numprocesses=auto",
    "--basetemp={env_tmp_dir}",
    {replace = "posargs", default = [], extend = true},
]]

[tool.tox.env.stress]
description = "high-iteration stress tests for race conditions"
commands = [[
    "pytest", "-v", "--tb=short", "-x", "-m", "stress",
    "--basetemp={env_tmp_dir}",
    "--override-ini=addopts=",
    {replace = "posargs", default = [], extend = true},
]]

[tool.tox.env.style]
description = "run all pre-commit hooks on all files"
dependency_groups = ["pre-commit"]
skip_install = true
commands = [["pre-commit", "run", "--all-files"]]

[tool.tox.env.typing]
description = "run static type checkers"
dependency_groups = ["typing"]
commands = [
    ["mypy"],
    ["pyright", "--ignoreexternal", "--verifytypes", "click"],
]

[tool.tox.env.docs]
description = "build docs"
dependency_groups = ["docs"]
commands = [["sphinx-build", "-E", "-W", "-b", "dirhtml", "docs", "docs/_build/dirhtml"]]

[tool.tox.env.docs-auto]
description = "continuously rebuild docs and start a local server"
dependency_groups = ["docs", "docs-auto"]
commands = [["sphinx-autobuild", "-W", "-b", "dirhtml", "--watch", "src", "docs", "docs/_build/dirhtml"]]

[tool.tox.env.update-actions]
description = "update GitHub Actions pins"
labels = ["update"]
dependency_groups = ["gha-update"]
skip_install = true
commands = [["gha-update"]]

[tool.tox.env.update-pre_commit]
description = "update pre-commit pins"
labels = ["update"]
dependency_groups = ["pre-commit"]
skip_install = true
commands = [["pre-commit", "autoupdate", "--freeze", "-j4"]]

[tool.tox.env.update-requirements]
description = "update uv lock"
labels = ["update"]
dependency_groups = []
no_default_groups = true
skip_install = true
commands = [["uv", "lock", {replace = "posargs", default = ["-U"], extend = true}]]

var request = require('supertest')
  , app = require('../../examples/ejs');

describe('ejs', function(){
  describe('GET /', function(){
    it('should respond with html', function(done){
      request(app)
      .get('/')
      .expect('Content-Type', 'text/html; charset=utf-8')
      .expect(/<li>tobi &lt;tobi@learnboost\.com&gt;<\/li>/)
      .expect(/<li>loki &lt;loki@learnboost\.com&gt;<\/li>/)
      .expect(/<li>jane &lt;jane@learnboost\.com&gt;<\/li>/)
      .expect(200, done)
    })
  })
})

#!/usr/bin/env python3

import glob
import subprocess

if __name__ == '__main__':
    cov_files = list(glob.glob('tests/cov-report*.bin'))
    base_cmd = ['OpenCppCoverage', '--quiet', '--export_type=cobertura:cobertura.xml'] + ['--input_coverage={}'.format(f) for f in cov_files]
    subprocess.check_call(base_cmd)

import pytest

from jinja2 import Environment
from jinja2 import nodes
from jinja2 import Template
from jinja2 import TemplateSyntaxError
from jinja2 import UndefinedError
from jinja2.lexer import Token
from jinja2.lexer import TOKEN_BLOCK_BEGIN
from jinja2.lexer import TOKEN_BLOCK_END
from jinja2.lexer import TOKEN_EOF
from jinja2.lexer import TokenStream


class TestTokenStream:
    test_tokens = [
        Token(1, TOKEN_BLOCK_BEGIN, ""),
        Token(2, TOKEN_BLOCK_END, ""),
    ]

    def test_simple(self, env):
        ts = TokenStream(self.test_tokens, "foo", "bar")
        assert ts.current.type is TOKEN_BLOCK_BEGIN
        assert bool(ts)
        assert not bool(ts.eos)
        next(ts)
        assert ts.current.type is TOKEN_BLOCK_END
        assert bool(ts)
        assert not bool(ts.eos)
        next(ts)
        assert ts.current.type is TOKEN_EOF
        assert not bool(ts)
        assert bool(ts.eos)

    def test_iter(self, env):
        token_types = [t.type for t in TokenStream(self.test_tokens, "foo", "bar")]
        assert token_types == [
            "block_begin",
            "block_end",
        ]


class TestLexer:
    def test_raw1(self, env):
        tmpl = env.from_string(
            "{% raw %}foo{% endraw %}|{%raw%}{{ bar }}|{% baz %}{%       endraw    %}"
        )
        assert tmpl.render() == "foo|{{ bar }}|{% baz %}"

    def test_raw2(self, env):
        tmpl = env.from_string("1  {%- raw -%}   2   {%- endraw -%}   3")
        assert tmpl.render() == "123"

    def test_raw3(self, env):
        # The second newline after baz exists because it is AFTER the
        # {% raw %} and is ignored.
        env = Environment(lstrip_blocks=True, trim_blocks=True)
        tmpl = env.from_string("bar\n{% raw %}\n  {{baz}}2 spaces\n{% endraw %}\nfoo")
        assert tmpl.render(baz="test") == "bar\n\n  {{baz}}2 spaces\nfoo"

    def test_raw4(self, env):
        # The trailing dash of the {% raw -%} cleans both the spaces and
        # newlines up to the first character of data.
        env = Environment(lstrip_blocks=True, trim_blocks=False)
        tmpl = env.from_string(
            "bar\n{%- raw -%}\n\n  \n  2 spaces\n space{%- endraw -%}\nfoo"
        )
        assert tmpl.render() == "bar2 spaces\n spacefoo"

    def test_balancing(self, env):
        env = Environment("{%", "%}", "${", "}")
        tmpl = env.from_string(
            """{% for item in seq
            %}${{'foo': item}|upper}{% endfor %}"""
        )
        assert tmpl.render(seq=list(range(3))) == "{'FOO': 0}{'FOO': 1}{'FOO': 2}"

    def test_comments(self, env):
        env = Environment("<!--", "-->", "{", "}")
        tmpl = env.from_string(
            """\
<ul>
<!--- for item in seq -->
  <li>{item}</li>
<!--- endfor -->
</ul>"""
        )
        assert tmpl.render(seq=list(range(3))) == (
            "<ul>\n  <li>0</li>\n  <li>1</li>\n  <li>2</li>\n</ul>"
        )

    def test_string_escapes(self, env):
        for char in "\0", "\u2668", "\xe4", "\t", "\r", "\n":
            tmpl = env.from_string(f"{{{{ {char!r} }}}}")
            assert tmpl.render() == char
        assert env.from_string('{{ "\N{HOT SPRINGS}" }}').render() == "\u2668"

    def test_bytefallback(self, env):
        from pprint import pformat

        tmpl = env.from_string("""{{ 'foo'|pprint }}|{{ 'bär'|pprint }}""")
        assert tmpl.render() == pformat("foo") + "|" + pformat("bär")

    def test_operators(self, env):
        from jinja2.lexer import operators

        for test, expect in operators.items():
            if test in "([{}])":
                continue
            stream = env.lexer.tokenize(f"{{{{ {test} }}}}")
            next(stream)
            assert stream.current.type == expect

    def test_normalizing(self, env):
        for seq in "\r", "\r\n", "\n":
            env = Environment(newline_sequence=seq)
            tmpl = env.from_string("1\n2\r\n3\n4\n")
            result = tmpl.render()
            assert result.replace(seq, "X") == "1X2X3X4"

    def test_trailing_newline(self, env):
        for keep in [True, False]:
            env = Environment(keep_trailing_newline=keep)
            for template, expected in [
                ("", {}),
                ("no\nnewline", {}),
                ("with\nnewline\n", {False: "with\nnewline"}),
                ("with\nseveral\n\n\n", {False: "with\nseveral\n\n"}),
            ]:
                tmpl = env.from_string(template)
                expect = expected.get(keep, template)
                result = tmpl.render()
                assert result == expect, (keep, template, result, expect)

    @pytest.mark.parametrize(
        ("name", "valid"),
        [
            ("foo", True),
            ("föö", True),
            ("き", True),
            ("_", True),
            ("1a", False),  # invalid ascii start
            ("a-", False),  # invalid ascii continue
            ("\U0001f40da", False),  # invalid unicode start
            ("a🐍\U0001f40d", False),  # invalid unicode continue
            # start characters not matched by \w
            ("\u1885", True),
            ("\u1886", True),
            ("\u2118", True),
            ("\u212e", True),
            # continue character not matched by \w
            ("\xb7", False),
            ("a\xb7", True),
        ],
    )
    def test_name(self, env, name, valid):
        t = "{{ " + name + " }}"

        if valid:
            # valid for version being tested, shouldn't raise
            env.from_string(t)
        else:
            pytest.raises(TemplateSyntaxError, env.from_string, t)

    def test_lineno_with_strip(self, env):
        tokens = env.lex(
            """\
<html>
    <body>
    {%- block content -%}
        <hr>
        {{ item }}
    {% endblock %}
    </body>
</html>"""
        )
        for tok in tokens:
            lineno, token_type, value = tok
            if token_type == "name" and value == "item":
                assert lineno == 5
                break


class TestParser:
    def test_php_syntax(self, env):
        env = Environment("<?", "?>", "<?=", "?>", "<!--", "-->")
        tmpl = env.from_string(
            """\
<!-- I'm a comment, I'm not interesting -->\
<? for item in seq -?>
    <?= item ?>
<?- endfor ?>"""
        )
        assert tmpl.render(seq=list(range(5))) == "01234"

    def test_erb_syntax(self, env):
        env = Environment("<%", "%>", "<%=", "%>", "<%#", "%>")
        tmpl = env.from_string(
            """\
<%# I'm a comment, I'm not interesting %>\
<% for item in seq -%>
    <%= item %>
<%- endfor %>"""
        )
        assert tmpl.render(seq=list(range(5))) == "01234"

    def test_comment_syntax(self, env):
        env = Environment("<!--", "-->", "${", "}", "<!--#", "-->")
        tmpl = env.from_string(
            """\
<!--# I'm a comment, I'm not interesting -->\
<!-- for item in seq --->
    ${item}
<!--- endfor -->"""
        )
        assert tmpl.render(seq=list(range(5))) == "01234"

    def test_balancing(self, env):
        tmpl = env.from_string("""{{{'foo':'bar'}.foo}}""")
        assert tmpl.render() == "bar"

    def test_start_comment(self, env):
        tmpl = env.from_string(
            """{# foo comment
and bar comment #}
{% macro blub() %}foo{% endmacro %}
{{ blub() }}"""
        )
        assert tmpl.render().strip() == "foo"

    def test_line_syntax(self, env):
        env = Environment("<%", "%>", "${", "}", "<%#", "%>", "%")
        tmpl = env.from_string(
            """\
<%# regular comment %>
% for item in seq:
    ${item}
% endfor"""
        )
        assert [
            int(x.strip()) for x in tmpl.render(seq=list(range(5))).split()
        ] == list(range(5))

        env = Environment("<%", "%>", "${", "}", "<%#", "%>", "%", "##")
        tmpl = env.from_string(
            """\
<%# regular comment %>
% for item in seq:
    ${item} ## the rest of the stuff
% endfor"""
        )
        assert [
            int(x.strip()) for x in tmpl.render(seq=list(range(5))).split()
        ] == list(range(5))

    def test_line_syntax_priority(self, env):
        # XXX: why is the whitespace there in front of the newline?
        env = Environment("{%", "%}", "${", "}", "/*", "*/", "##", "#")
        tmpl = env.from_string(
            """\
/* ignore me.
   I'm a multiline comment */
## for item in seq:
* ${item}          # this is just extra stuff
## endfor"""
        )
        assert tmpl.render(seq=[1, 2]).strip() == "* 1\n* 2"
        env = Environment("{%", "%}", "${", "}", "/*", "*/", "#", "##")
        tmpl = env.from_string(
            """\
/* ignore me.
   I'm a multiline comment */
# for item in seq:
* ${item}          ## this is just extra stuff
    ## extra stuff i just want to ignore
# endfor"""
        )
        assert tmpl.render(seq=[1, 2]).strip() == "* 1\n\n* 2"

    def test_error_messages(self, env):
        def assert_error(code, expected):
            with pytest.raises(TemplateSyntaxError, match=expected):
                Template(code)

        assert_error(
            "{% for item in seq %}...{% endif %}",
            "Encountered unknown tag 'endif'. Jinja was looking "
            "for the following tags: 'endfor' or 'else'. The "
            "innermost block that needs to be closed is 'for'.",
        )
        assert_error(
            "{% if foo %}{% for item in seq %}...{% endfor %}{% endfor %}",
            "Encountered unknown tag 'endfor'. Jinja was looking for "
            "the following tags: 'elif' or 'else' or 'endif'. The "
            "innermost block that needs to be closed is 'if'.",
        )
        assert_error(
            "{% if foo %}",
            "Unexpected end of template. Jinja was looking for the "
            "following tags: 'elif' or 'else' or 'endif'. The "
            "innermost block that needs to be closed is 'if'.",
        )
        assert_error(
            "{% for item in seq %}",
            "Unexpected end of template. Jinja was looking for the "
            "following tags: 'endfor' or 'else'. The innermost block "
            "that needs to be closed is 'for'.",
        )
        assert_error(
            "{% block foo-bar-baz %}",
            "Block names in Jinja have to be valid Python identifiers "
            "and may not contain hyphens, use an underscore instead.",
        )
        assert_error("{% unknown_tag %}", "Encountered unknown tag 'unknown_tag'.")


class TestSyntax:
    def test_call(self, env):
        env = Environment()
        env.globals["foo"] = lambda a, b, c, e, g: a + b + c + e + g
        tmpl = env.from_string("{{ foo('a', c='d', e='f', *['b'], **{'g': 'h'}) }}")
        assert tmpl.render() == "abdfh"

    def test_slicing(self, env):
        tmpl = env.from_string("{{ [1, 2, 3][:] }}|{{ [1, 2, 3][::-1] }}")
        assert tmpl.render() == "[1, 2, 3]|[3, 2, 1]"

    def test_attr(self, env):
        tmpl = env.from_string("{{ foo.bar }}|{{ foo['bar'] }}")
        assert tmpl.render(foo={"bar": 42}) == "42|42"

    def test_subscript(self, env):
        tmpl = env.from_string("{{ foo[0] }}|{{ foo[-1] }}")
        assert tmpl.render(foo=[0, 1, 2]) == "0|2"

    def test_tuple(self, env):
        tmpl = env.from_string("{{ () }}|{{ (1,) }}|{{ (1, 2) }}")
        assert tmpl.render() == "()|(1,)|(1, 2)"

    def test_math(self, env):
        tmpl = env.from_string("{{ (1 + 1 * 2) - 3 / 2 }}|{{ 2**3 }}")
        assert tmpl.render() == "1.5|8"

    def test_div(self, env):
        tmpl = env.from_string("{{ 3 // 2 }}|{{ 3 / 2 }}|{{ 3 % 2 }}")
        assert tmpl.render() == "1|1.5|1"

    def test_unary(self, env):
        tmpl = env.from_string("{{ +3 }}|{{ -3 }}")
        assert tmpl.render() == "3|-3"

    def test_concat(self, env):
        tmpl = env.from_string("{{ [1, 2] ~ 'foo' }}")
        assert tmpl.render() == "[1, 2]foo"

    @pytest.mark.parametrize(
        ("a", "op", "b"),
        [
            (1, ">", 0),
            (1, ">=", 1),
            (2, "<", 3),
            (3, "<=", 4),
            (4, "==", 4),
            (4, "!=", 5),
        ],
    )
    def test_compare(self, env, a, op, b):
        t = env.from_string(f"{{{{ {a} {op} {b} }}}}")
        assert t.render() == "True"

    def test_compare_parens(self, env):
        t = env.from_string("{{ i * (j < 5) }}")
        assert t.render(i=2, j=3) == "2"

    @pytest.mark.parametrize(
        ("src", "expect"),
        [
            ("{{ 4 < 2 < 3 }}", "False"),
            ("{{ a < b < c }}", "False"),
            ("{{ 4 > 2 > 3 }}", "False"),
            ("{{ a > b > c }}", "False"),
            ("{{ 4 > 2 < 3 }}", "True"),
            ("{{ a > b < c }}", "True"),
        ],
    )
    def test_compare_compound(self, env, src, expect):
        t = env.from_string(src)
        assert t.render(a=4, b=2, c=3) == expect

    def test_inop(self, env):
        tmpl = env.from_string("{{ 1 in [1, 2, 3] }}|{{ 1 not in [1, 2, 3] }}")
        assert tmpl.render() == "True|False"

    @pytest.mark.parametrize("value", ("[]", "{}", "()"))
    def test_collection_literal(self, env, value):
        t = env.from_string(f"{{{{ {value} }}}}")
        assert t.render() == value

    @pytest.mark.parametrize(
        ("value", "expect"),
        (
            ("1", "1"),
            ("123", "123"),
            ("12_34_56", "123456"),
            ("1.2", "1.2"),
            ("34.56", "34.56"),
            ("3_4.5_6", "34.56"),
            ("1e0", "1.0"),
            ("10e1", "100.0"),
            ("2.5e100", "2.5e+100"),
            ("2.5e+100", "2.5e+100"),
            ("25.6e-10", "2.56e-09"),
            ("1_2.3_4e5_6", "1.234e+57"),
            ("0", "0"),
            ("0_00", "0"),
            ("0b1001_1111", "159"),
            ("0o123", "83"),
            ("0o1_23", "83"),
            ("0x123abc", "1194684"),
            ("0x12_3abc", "1194684"),
        ),
    )
    def test_numeric_literal(self, env, value, expect):
        t = env.from_string(f"{{{{ {value} }}}}")
        assert t.render() == expect

    def test_bool(self, env):
        tmpl = env.from_string(
            "{{ true and false }}|{{ false or true }}|{{ not false }}"
        )
        assert tmpl.render() == "False|True|True"

    def test_grouping(self, env):
        tmpl = env.from_string(
            "{{ (true and false) or (false and true) and not false }}"
        )
        assert tmpl.render() == "False"

    def test_django_attr(self, env):
        tmpl = env.from_string("{{ [1, 2, 3].0 }}|{{ [[1]].0.0 }}")
        assert tmpl.render() == "1|1"

    def test_conditional_expression(self, env):
        tmpl = env.from_string("""{{ 0 if true else 1 }}""")
        assert tmpl.render() == "0"

    def test_short_conditional_expression(self, env):
        tmpl = env.from_string("<{{ 1 if false }}>")
        assert tmpl.render() == "<>"

        tmpl = env.from_string("<{{ (1 if false).bar }}>")
        pytest.raises(UndefinedError, tmpl.render)

    def test_filter_priority(self, env):
        tmpl = env.from_string('{{ "foo"|upper + "bar"|upper }}')
        assert tmpl.render() == "FOOBAR"

    def test_function_calls(self, env):
        tests = [
            (True, "*foo, bar"),
            (True, "*foo, *bar"),
            (True, "**foo, *bar"),
            (True, "**foo, bar"),
            (True, "**foo, **bar"),
            (True, "**foo, bar=42"),
            (False, "foo, bar"),
            (False, "foo, bar=42"),
            (False, "foo, bar=23, *args"),
            (False, "foo, *args, bar=23"),
            (False, "a, b=c, *d, **e"),
            (False, "*foo, bar=42"),
            (False, "*foo, **bar"),
            (False, "*foo, bar=42, **baz"),
            (False, "foo, *args, bar=23, **baz"),
        ]
        for should_fail, sig in tests:
            if should_fail:
                with pytest.raises(TemplateSyntaxError):
                    env.from_string(f"{{{{ foo({sig}) }}}}")
            else:
                env.from_string(f"foo({sig})")

    def test_tuple_expr(self, env):
        for tmpl in [
            "{{ () }}",
            "{{ (1, 2) }}",
            "{{ (1, 2,) }}",
            "{{ 1, }}",
            "{{ 1, 2 }}",
            "{% for foo, bar in seq %}...{% endfor %}",
            "{% for x in foo, bar %}...{% endfor %}",
            "{% for x in foo, %}...{% endfor %}",
        ]:
            assert env.from_string(tmpl)

    def test_trailing_comma(self, env):
        tmpl = env.from_string("{{ (1, 2,) }}|{{ [1, 2,] }}|{{ {1: 2,} }}")
        assert tmpl.render().lower() == "(1, 2)|[1, 2]|{1: 2}"

    def test_block_end_name(self, env):
        env.from_string("{% block foo %}...{% endblock foo %}")
        pytest.raises(
            TemplateSyntaxError, env.from_string, "{% block x %}{% endblock y %}"
        )

    def test_constant_casing(self, env):
        for const in True, False, None:
            const = str(const)
            tmpl = env.from_string(
                f"{{{{ {const} }}}}|{{{{ {const.lower()} }}}}|{{{{ {const.upper()} }}}}"
            )
            assert tmpl.render() == f"{const}|{const}|"

    def test_test_chaining(self, env):
        pytest.raises(
            TemplateSyntaxError, env.from_string, "{{ foo is string is sequence }}"
        )
        assert env.from_string("{{ 42 is string or 42 is number }}").render() == "True"

    def test_string_concatenation(self, env):
        tmpl = env.from_string('{{ "foo" "bar" "baz" }}')
        assert tmpl.render() == "foobarbaz"

    def test_notin(self, env):
        bar = range(100)
        tmpl = env.from_string("""{{ not 42 in bar }}""")
        assert tmpl.render(bar=bar) == "False"

    def test_operator_precedence(self, env):
        tmpl = env.from_string("""{{ 2 * 3 + 4 % 2 + 1 - 2 }}""")
        assert tmpl.render() == "5"

    def test_implicit_subscribed_tuple(self, env):
        class Foo:
            def __getitem__(self, x):
                return x

        t = env.from_string("{{ foo[1, 2] }}")
        assert t.render(foo=Foo()) == "(1, 2)"

    def test_raw2(self, env):
        tmpl = env.from_string("{% raw %}{{ FOO }} and {% BAR %}{% endraw %}")
        assert tmpl.render() == "{{ FOO }} and {% BAR %}"

    def test_const(self, env):
        tmpl = env.from_string(
            "{{ true }}|{{ false }}|{{ none }}|"
            "{{ none is defined }}|{{ missing is defined }}"
        )
        assert tmpl.render() == "True|False|None|True|False"

    def test_neg_filter_priority(self, env):
        node = env.parse("{{ -1|foo }}")
        assert isinstance(node.body[0].nodes[0], nodes.Filter)
        assert isinstance(node.body[0].nodes[0].node, nodes.Neg)

    def test_const_assign(self, env):
        constass1 = """{% set true = 42 %}"""
        constass2 = """{% for none in seq %}{% endfor %}"""
        for tmpl in constass1, constass2:
            pytest.raises(TemplateSyntaxError, env.from_string, tmpl)

    def test_localset(self, env):
        tmpl = env.from_string(
            """{% set foo = 0 %}\
{% for item in [1, 2] %}{% set foo = 1 %}{% endfor %}\
{{ foo }}"""
        )
        assert tmpl.render() == "0"

    def test_parse_unary(self, env):
        tmpl = env.from_string('{{ -foo["bar"] }}')
        assert tmpl.render(foo={"bar": 42}) == "-42"
        tmpl = env.from_string('{{ -foo["bar"]|abs }}')
        assert tmpl.render(foo={"bar": 42}) == "42"


class TestLstripBlocks:
    def test_lstrip(self, env):
        env = Environment(lstrip_blocks=True, trim_blocks=False)
        tmpl = env.from_string("""    {% if True %}\n    {% endif %}""")
        assert tmpl.render() == "\n"

    def test_lstrip_trim(self, env):
        env = Environment(lstrip_blocks=True, trim_blocks=True)
        tmpl = env.from_string("""    {% if True %}\n    {% endif %}""")
        assert tmpl.render() == ""

    def test_no_lstrip(self, env):
        env = Environment(lstrip_blocks=True, trim_blocks=False)
        tmpl = env.from_string("""    {%+ if True %}\n    {%+ endif %}""")
        assert tmpl.render() == "    \n    "

    def test_lstrip_blocks_false_with_no_lstrip(self, env):
        # Test that + is a NOP (but does not cause an error) if lstrip_blocks=False
        env = Environment(lstrip_blocks=False, trim_blocks=False)
        tmpl = env.from_string("""    {% if True %}\n    {% endif %}""")
        assert tmpl.render() == "    \n    "
        tmpl = env.from_string("""    {%+ if True %}\n    {%+ endif %}""")
        assert tmpl.render() == "    \n    "

    def test_lstrip_endline(self, env):
        env = Environment(lstrip_blocks=True, trim_blocks=False)
        tmpl = env.from_string("""    hello{% if True %}\n    goodbye{% endif %}""")
        assert tmpl.render() == "    hello\n    goodbye"

    def test_lstrip_inline(self, env):
        env = Environment(lstrip_blocks=True, trim_blocks=False)
        tmpl = env.from_string("""    {% if True %}hello    {% endif %}""")
        assert tmpl.render() == "hello    "

    def test_lstrip_nested(self, env):
        env = Environment(lstrip_blocks=True, trim_blocks=False)
        tmpl = env.from_string(
            """    {% if True %}a {% if True %}b {% endif %}c {% endif %}"""
        )
        assert tmpl.render() == "a b c "

    def test_lstrip_left_chars(self, env):
        env = Environment(lstrip_blocks=True, trim_blocks=False)
        tmpl = env.from_string(
            """    abc {% if True %}
        hello{% endif %}"""
        )
        assert tmpl.render() == "    abc \n        hello"

    def test_lstrip_embeded_strings(self, env):
        env = Environment(lstrip_blocks=True, trim_blocks=False)
        tmpl = env.from_string("""    {% set x = " {% str %} " %}{{ x }}""")
        assert tmpl.render() == " {% str %} "

    def test_lstrip_preserve_leading_newlines(self, env):
        env = Environment(lstrip_blocks=True, trim_blocks=False)
        tmpl = env.from_string("""\n\n\n{% set hello = 1 %}""")
        assert tmpl.render() == "\n\n\n"

    def test_lstrip_comment(self, env):
        env = Environment(lstrip_blocks=True, trim_blocks=False)
        tmpl = env.from_string(
            """    {# if True #}
hello
    {#endif#}"""
        )
        assert tmpl.render() == "\nhello\n"

    def test_lstrip_angle_bracket_simple(self, env):
        env = Environment(
            "<%",
            "%>",
            "${",
            "}",
            "<%#",
            "%>",
            "%",
            "##",
            lstrip_blocks=True,
            trim_blocks=True,
        )
        tmpl = env.from_string("""    <% if True %>hello    <% endif %>""")
        assert tmpl.render() == "hello    "

    def test_lstrip_angle_bracket_comment(self, env):
        env = Environment(
            "<%",
            "%>",
            "${",
            "}",
            "<%#",
            "%>",
            "%",
            "##",
            lstrip_blocks=True,
            trim_blocks=True,
        )
        tmpl = env.from_string("""    <%# if True %>hello    <%# endif %>""")
        assert tmpl.render() == "hello    "

    def test_lstrip_angle_bracket(self, env):
        env = Environment(
            "<%",
            "%>",
            "${",
            "}",
            "<%#",
            "%>",
            "%",
            "##",
            lstrip_blocks=True,
            trim_blocks=True,
        )
        tmpl = env.from_string(
            """\
    <%# regular comment %>
    <% for item in seq %>
${item} ## the rest of the stuff
   <% endfor %>"""
        )
        assert tmpl.render(seq=range(5)) == "".join(f"{x}\n" for x in range(5))

    def test_lstrip_angle_bracket_compact(self, env):
        env = Environment(
            "<%",
            "%>",
            "${",
            "}",
            "<%#",
            "%>",
            "%",
            "##",
            lstrip_blocks=True,
            trim_blocks=True,
        )
        tmpl = env.from_string(
            """\
    <%#regular comment%>
    <%for item in seq%>
${item} ## the rest of the stuff
   <%endfor%>"""
        )
        assert tmpl.render(seq=range(5)) == "".join(f"{x}\n" for x in range(5))

    def test_lstrip_blocks_outside_with_new_line(self):
        env = Environment(lstrip_blocks=True, trim_blocks=False)
        tmpl = env.from_string(
            "  {% if kvs %}(\n"
            "   {% for k, v in kvs %}{{ k }}={{ v }} {% endfor %}\n"
            "  ){% endif %}"
        )
        out = tmpl.render(kvs=[("a", 1), ("b", 2)])
        assert out == "(\na=1 b=2 \n  )"

    def test_lstrip_trim_blocks_outside_with_new_line(self):
        env = Environment(lstrip_blocks=True, trim_blocks=True)
        tmpl = env.from_string(
            "  {% if kvs %}(\n"
            "   {% for k, v in kvs %}{{ k }}={{ v }} {% endfor %}\n"
            "  ){% endif %}"
        )
        out = tmpl.render(kvs=[("a", 1), ("b", 2)])
        assert out == "(\na=1 b=2   )"

    def test_lstrip_blocks_inside_with_new_line(self):
        env = Environment(lstrip_blocks=True, trim_blocks=False)
        tmpl = env.from_string(
            "  ({% if kvs %}\n"
            "   {% for k, v in kvs %}{{ k }}={{ v }} {% endfor %}\n"
            "  {% endif %})"
        )
        out = tmpl.render(kvs=[("a", 1), ("b", 2)])
        assert out == "  (\na=1 b=2 \n)"

    def test_lstrip_trim_blocks_inside_with_new_line(self):
        env = Environment(lstrip_blocks=True, trim_blocks=True)
        tmpl = env.from_string(
            "  ({% if kvs %}\n"
            "   {% for k, v in kvs %}{{ k }}={{ v }} {% endfor %}\n"
            "  {% endif %})"
        )
        out = tmpl.render(kvs=[("a", 1), ("b", 2)])
        assert out == "  (a=1 b=2 )"

    def test_lstrip_blocks_without_new_line(self):
        env = Environment(lstrip_blocks=True, trim_blocks=False)
        tmpl = env.from_string(
            "  {% if kvs %}"
            "   {% for k, v in kvs %}{{ k }}={{ v }} {% endfor %}"
            "  {% endif %}"
        )
        out = tmpl.render(kvs=[("a", 1), ("b", 2)])
        assert out == "   a=1 b=2   "

    def test_lstrip_trim_blocks_without_new_line(self):
        env = Environment(lstrip_blocks=True, trim_blocks=True)
        tmpl = env.from_string(
            "  {% if kvs %}"
            "   {% for k, v in kvs %}{{ k }}={{ v }} {% endfor %}"
            "  {% endif %}"
        )
        out = tmpl.render(kvs=[("a", 1), ("b", 2)])
        assert out == "   a=1 b=2   "

    def test_lstrip_blocks_consume_after_without_new_line(self):
        env = Environment(lstrip_blocks=True, trim_blocks=False)
        tmpl = env.from_string(
            "  {% if kvs -%}"
            "   {% for k, v in kvs %}{{ k }}={{ v }} {% endfor -%}"
            "  {% endif -%}"
        )
        out = tmpl.render(kvs=[("a", 1), ("b", 2)])
        assert out == "a=1 b=2 "

    def test_lstrip_trim_blocks_consume_before_without_new_line(self):
        env = Environment(lstrip_blocks=False, trim_blocks=False)
        tmpl = env.from_string(
            "  {%- if kvs %}"
            "   {%- for k, v in kvs %}{{ k }}={{ v }} {% endfor -%}"
            "  {%- endif %}"
        )
        out = tmpl.render(kvs=[("a", 1), ("b", 2)])
        assert out == "a=1 b=2 "

    def test_lstrip_trim_blocks_comment(self):
        env = Environment(lstrip_blocks=True, trim_blocks=True)
        tmpl = env.from_string(" {# 1 space #}\n  {# 2 spaces #}    {# 4 spaces #}")
        out = tmpl.render()
        assert out == " " * 4

    def test_lstrip_trim_blocks_raw(self):
        env = Environment(lstrip_blocks=True, trim_blocks=True)
        tmpl = env.from_string("{{x}}\n{%- raw %} {% endraw -%}\n{{ y }}")
        out = tmpl.render(x=1, y=2)
        assert out == "1 2"

    def test_php_syntax_with_manual(self, env):
        env = Environment(
            "<?", "?>", "<?=", "?>", "<!--", "-->", lstrip_blocks=True, trim_blocks=True
        )
        tmpl = env.from_string(
            """\
    <!-- I'm a comment, I'm not interesting -->
    <? for item in seq -?>
        <?= item ?>
    <?- endfor ?>"""
        )
        assert tmpl.render(seq=range(5)) == "01234"

    def test_php_syntax(self, env):
        env = Environment(
            "<?", "?>", "<?=", "?>", "<!--", "-->", lstrip_blocks=True, trim_blocks=True
        )
        tmpl = env.from_string(
            """\
    <!-- I'm a comment, I'm not interesting -->
    <? for item in seq ?>
        <?= item ?>
    <? endfor ?>"""
        )
        assert tmpl.render(seq=range(5)) == "".join(f"        {x}\n" for x in range(5))

    def test_php_syntax_compact(self, env):
        env = Environment(
            "<?", "?>", "<?=", "?>", "<!--", "-->", lstrip_blocks=True, trim_blocks=True
        )
        tmpl = env.from_string(
            """\
    <!-- I'm a comment, I'm not interesting -->
    <?for item in seq?>
        <?=item?>
    <?endfor?>"""
        )
        assert tmpl.render(seq=range(5)) == "".join(f"        {x}\n" for x in range(5))

    def test_erb_syntax(self, env):
        env = Environment(
            "<%", "%>", "<%=", "%>", "<%#", "%>", lstrip_blocks=True, trim_blocks=True
        )
        tmpl = env.from_string(
            """\
<%# I'm a comment, I'm not interesting %>
    <% for item in seq %>
    <%= item %>
    <% endfor %>
"""
        )
        assert tmpl.render(seq=range(5)) == "".join(f"    {x}\n" for x in range(5))

    def test_erb_syntax_with_manual(self, env):
        env = Environment(
            "<%", "%>", "<%=", "%>", "<%#", "%>", lstrip_blocks=True, trim_blocks=True
        )
        tmpl = env.from_string(
            """\
<%# I'm a comment, I'm not interesting %>
    <% for item in seq -%>
        <%= item %>
    <%- endfor %>"""
        )
        assert tmpl.render(seq=range(5)) == "01234"

    def test_erb_syntax_no_lstrip(self, env):
        env = Environment(
            "<%", "%>", "<%=", "%>", "<%#", "%>", lstrip_blocks=True, trim_blocks=True
        )
        tmpl = env.from_string(
            """\
<%# I'm a comment, I'm not interesting %>
    <%+ for item in seq -%>
        <%= item %>
    <%- endfor %>"""
        )
        assert tmpl.render(seq=range(5)) == "    01234"

    def test_comment_syntax(self, env):
        env = Environment(
            "<!--",
            "-->",
            "${",
            "}",
            "<!--#",
            "-->",
            lstrip_blocks=True,
            trim_blocks=True,
        )
        tmpl = env.from_string(
            """\
<!--# I'm a comment, I'm not interesting -->\
<!-- for item in seq --->
    ${item}
<!--- endfor -->"""
        )
        assert tmpl.render(seq=range(5)) == "01234"


class TestTrimBlocks:
    def test_trim(self, env):
        env = Environment(trim_blocks=True, lstrip_blocks=False)
        tmpl = env.from_string("    {% if True %}\n    {% endif %}")
        assert tmpl.render() == "        "

    def test_no_trim(self, env):
        env = Environment(trim_blocks=True, lstrip_blocks=False)
        tmpl = env.from_string("    {% if True +%}\n    {% endif %}")
        assert tmpl.render() == "    \n    "

    def test_no_trim_outer(self, env):
        env = Environment(trim_blocks=True, lstrip_blocks=False)
        tmpl = env.from_string("{% if True %}X{% endif +%}\nmore things")
        assert tmpl.render() == "X\nmore things"

    def test_lstrip_no_trim(self, env):
        env = Environment(trim_blocks=True, lstrip_blocks=True)
        tmpl = env.from_string("    {% if True +%}\n    {% endif %}")
        assert tmpl.render() == "\n"

    def test_trim_blocks_false_with_no_trim(self, env):
        # Test that + is a NOP (but does not cause an error) if trim_blocks=False
        env = Environment(trim_blocks=False, lstrip_blocks=False)
        tmpl = env.from_string("    {% if True %}\n    {% endif %}")
        assert tmpl.render() == "    \n    "
        tmpl = env.from_string("    {% if True +%}\n    {% endif %}")
        assert tmpl.render() == "    \n    "

        tmpl = env.from_string("    {# comment #}\n    ")
        assert tmpl.render() == "    \n    "
        tmpl = env.from_string("    {# comment +#}\n    ")
        assert tmpl.render() == "    \n    "

        tmpl = env.from_string("    {% raw %}{% endraw %}\n    ")
        assert tmpl.render() == "    \n    "
        tmpl = env.from_string("    {% raw %}{% endraw +%}\n    ")
        assert tmpl.render() == "    \n    "

    def test_trim_nested(self, env):
        env = Environment(trim_blocks=True, lstrip_blocks=True)
        tmpl = env.from_string(
            "    {% if True %}\na {% if True %}\nb {% endif %}\nc {% endif %}"
        )
        assert tmpl.render() == "a b c "

    def test_no_trim_nested(self, env):
        env = Environment(trim_blocks=True, lstrip_blocks=True)
        tmpl = env.from_string(
            "    {% if True +%}\na {% if True +%}\nb {% endif +%}\nc {% endif %}"
        )
        assert tmpl.render() == "\na \nb \nc "

    def test_comment_trim(self, env):
        env = Environment(trim_blocks=True, lstrip_blocks=True)
        tmpl = env.from_string("""    {# comment #}\n\n  """)
        assert tmpl.render() == "\n  "

    def test_comment_no_trim(self, env):
        env = Environment(trim_blocks=True, lstrip_blocks=True)
        tmpl = env.from_string("""    {# comment +#}\n\n  """)
        assert tmpl.render() == "\n\n  "

    def test_multiple_comment_trim_lstrip(self, env):
        env = Environment(trim_blocks=True, lstrip_blocks=True)
        tmpl = env.from_string(
            "   {# comment #}\n\n{# comment2 #}\n   \n{# comment3 #}\n\n "
        )
        assert tmpl.render() == "\n   \n\n "

    def test_multiple_comment_no_trim_lstrip(self, env):
        env = Environment(trim_blocks=True, lstrip_blocks=True)
        tmpl = env.from_string(
            "   {# comment +#}\n\n{# comment2 +#}\n   \n{# comment3 +#}\n\n "
        )
        assert tmpl.render() == "\n\n\n   \n\n\n "

    def test_raw_trim_lstrip(self, env):
        env = Environment(trim_blocks=True, lstrip_blocks=True)
        tmpl = env.from_string("{{x}}{% raw %}\n\n    {% endraw %}\n\n{{ y }}")
        assert tmpl.render(x=1, y=2) == "1\n\n\n2"

    def test_raw_no_trim_lstrip(self, env):
        env = Environment(trim_blocks=False, lstrip_blocks=True)
        tmpl = env.from_string("{{x}}{% raw %}\n\n      {% endraw +%}\n\n{{ y }}")
        assert tmpl.render(x=1, y=2) == "1\n\n\n\n2"

        # raw blocks do not process inner text, so start tag cannot ignore trim
        with pytest.raises(TemplateSyntaxError):
            tmpl = env.from_string("{{x}}{% raw +%}\n\n  {% endraw +%}\n\n{{ y }}")

    def test_no_trim_angle_bracket(self, env):
        env = Environment(
            "<%", "%>", "${", "}", "<%#", "%>", lstrip_blocks=True, trim_blocks=True
        )
        tmpl = env.from_string("    <% if True +%>\n\n    <% endif %>")
        assert tmpl.render() == "\n\n"

        tmpl = env.from_string("    <%# comment +%>\n\n   ")
        assert tmpl.render() == "\n\n   "

    def test_no_trim_php_syntax(self, env):
        env = Environment(
            "<?",
            "?>",
            "<?=",
            "?>",
            "<!--",
            "-->",
            lstrip_blocks=False,
            trim_blocks=True,
        )
        tmpl = env.from_string("    <? if True +?>\n\n    <? endif ?>")
        assert tmpl.render() == "    \n\n    "
        tmpl = env.from_string("    <!-- comment +-->\n\n    ")
        assert tmpl.render() == "    \n\n    "

import test from 'ava';
import WeakableMap from '../source/core/utils/weakable-map.js';

test('works as expected', t => {
	const weakable = new WeakableMap();

	weakable.set('hello', 'world');

	t.true(weakable.has('hello'));
	t.false(weakable.has('foobar'));
	t.is(weakable.get('hello'), 'world');
	t.is(weakable.get('foobar'), undefined);

	const object = {};
	const anotherObject = {};
	weakable.set(object, 'world');

	t.true(weakable.has(object));
	t.false(weakable.has(anotherObject));
	t.is(weakable.get(object), 'world');
	t.is(weakable.get(anotherObject), undefined);
});

'use strict';

const _ = require('lodash');
const docdown = require('docdown');
const fs = require('fs-extra');
const path = require('path');

const util = require('../common/util');

const basePath = path.join(__dirname, '..', '..');
const docPath = path.join(basePath, 'doc');
const readmePath = path.join(docPath, 'README.md');

const pkg = require('../../package.json');
const version = pkg.version;

const config = {
  'base': {
    'path': path.join(basePath, 'lodash.js'),
    'title': `<a href="https://lodash.com/">lodash</a> <span>v${ version }</span>`,
    'toc': 'categories',
    'url': `https://github.com/lodash/lodash/blob/${ version }/lodash.js`
  },
  'github': {
    'style': 'github',
    'sublinks': [npmLink('&#x24C3;', 'See the npm package')]
  },
  'site': {
    'entryLink': '<a href="${entryHref}" class="fa fa-link"></a>',
    'sourceLink': '[source](${sourceHref})',
    'tocHref': '',
    'tocLink': '',
    'sublinks': [npmLink('npm package')]
  }
};

/**
 * Composes a npm link from `text` and optional `title`.
 *
 * @private
 * @param {string} text The link text.
 * @param {string} [title] The link title.
 * @returns {string} Returns the composed npm link.
 */
function npmLink(text, title) {
  return (
    '<% if (name == "templateSettings" || !/^(?:methods|properties|seq)$/i.test(category)) {' +
      'print(' +
        '"[' + text + '](https://www.npmjs.com/package/lodash." + name.toLowerCase() + ' +
        '"' + (title == null ? '' : ' \\"' + title + '\\"') + ')"' +
      ');' +
    '} %>'
  );
}

/**
 * Post-process `markdown` to make adjustments.
 *
 * @private
 * @param {string} markdown The markdown to process.
 * @returns {string} Returns the processed markdown.
 */
function postprocess(markdown) {
  // Wrap symbol property identifiers in brackets.
  return markdown.replace(/\.(Symbol\.(?:[a-z]+[A-Z]?)+)/g, '[$1]');
}

/*----------------------------------------------------------------------------*/

/**
 * Creates the documentation markdown formatted for 'github' or 'site'.
 *
 * @private
 * @param {string} type The format type.
 */
function build(type) {
  const options = _.defaults({}, config.base, config[type]);
  const markdown = docdown(options);

  fs.writeFile(readmePath, postprocess(markdown), util.pitch);
}

build(_.last(process.argv));

import click


all_colors = (
    "black",
    "red",
    "green",
    "yellow",
    "blue",
    "magenta",
    "cyan",
    "white",
    "bright_black",
    "bright_red",
    "bright_green",
    "bright_yellow",
    "bright_blue",
    "bright_magenta",
    "bright_cyan",
    "bright_white",
)


@click.command()
def cli():
    """This script prints some colors. It will also automatically remove
    all ANSI styles if data is piped into a file.

    Give it a try!
    """
    for color in all_colors:
        click.echo(click.style(f"I am colored {color}", fg=color))
    for color in all_colors:
        click.echo(click.style(f"I am colored {color} and bold", fg=color, bold=True))
    for color in all_colors:
        click.echo(click.style(f"I am reverse colored {color}", fg=color, reverse=True))

    click.echo(click.style("I am blinking", blink=True))
    click.echo(click.style("I am underlined", underline=True))

"""A sandbox layer that ensures unsafe operations cannot be performed.
Useful when the template itself comes from an untrusted source.
"""

import operator
import types
import typing as t
from _string import formatter_field_name_split  # type: ignore
from collections import abc
from collections import deque
from functools import update_wrapper
from string import Formatter

from markupsafe import EscapeFormatter
from markupsafe import Markup

from .environment import Environment
from .exceptions import SecurityError
from .runtime import Context
from .runtime import Undefined

F = t.TypeVar("F", bound=t.Callable[..., t.Any])

#: maximum number of items a range may produce
MAX_RANGE = 100000

#: Unsafe function attributes.
UNSAFE_FUNCTION_ATTRIBUTES: set[str] = set()

#: Unsafe method attributes. Function attributes are unsafe for methods too.
UNSAFE_METHOD_ATTRIBUTES: set[str] = set()

#: unsafe generator attributes.
UNSAFE_GENERATOR_ATTRIBUTES = {"gi_frame", "gi_code"}

#: unsafe attributes on coroutines
UNSAFE_COROUTINE_ATTRIBUTES = {"cr_frame", "cr_code"}

#: unsafe attributes on async generators
UNSAFE_ASYNC_GENERATOR_ATTRIBUTES = {"ag_code", "ag_frame"}

_mutable_spec: tuple[tuple[type[t.Any], frozenset[str]], ...] = (
    (
        abc.MutableSet,
        frozenset(
            [
                "add",
                "clear",
                "difference_update",
                "discard",
                "pop",
                "remove",
                "symmetric_difference_update",
                "update",
            ]
        ),
    ),
    (
        abc.MutableMapping,
        frozenset(["clear", "pop", "popitem", "setdefault", "update"]),
    ),
    (
        abc.MutableSequence,
        frozenset(
            ["append", "clear", "pop", "reverse", "insert", "sort", "extend", "remove"]
        ),
    ),
    (
        deque,
        frozenset(
            [
                "append",
                "appendleft",
                "clear",
                "extend",
                "extendleft",
                "pop",
                "popleft",
                "remove",
                "rotate",
            ]
        ),
    ),
)


def safe_range(*args: int) -> range:
    """A range that can't generate ranges with a length of more than
    MAX_RANGE items.
    """
    rng = range(*args)

    if len(rng) > MAX_RANGE:
        raise OverflowError(
            "Range too big. The sandbox blocks ranges larger than"
            f" MAX_RANGE ({MAX_RANGE})."
        )

    return rng


def unsafe(f: F) -> F:
    """Marks a function or method as unsafe.

    .. code-block: python

        @unsafe
        def delete(self):
            pass
    """
    f.unsafe_callable = True  # type: ignore
    return f


def is_internal_attribute(obj: t.Any, attr: str) -> bool:
    """Test if the attribute given is an internal python attribute.  For
    example this function returns `True` for the `func_code` attribute of
    python objects.  This is useful if the environment method
    :meth:`~SandboxedEnvironment.is_safe_attribute` is overridden.

    >>> from jinja2.sandbox import is_internal_attribute
    >>> is_internal_attribute(str, "mro")
    True
    >>> is_internal_attribute(str, "upper")
    False
    """
    if isinstance(obj, types.FunctionType):
        if attr in UNSAFE_FUNCTION_ATTRIBUTES:
            return True
    elif isinstance(obj, types.MethodType):
        if attr in UNSAFE_FUNCTION_ATTRIBUTES or attr in UNSAFE_METHOD_ATTRIBUTES:
            return True
    elif isinstance(obj, type):
        if attr == "mro":
            return True
    elif isinstance(obj, (types.CodeType, types.TracebackType, types.FrameType)):
        return True
    elif isinstance(obj, types.GeneratorType):
        if attr in UNSAFE_GENERATOR_ATTRIBUTES:
            return True
    elif hasattr(types, "CoroutineType") and isinstance(obj, types.CoroutineType):
        if attr in UNSAFE_COROUTINE_ATTRIBUTES:
            return True
    elif hasattr(types, "AsyncGeneratorType") and isinstance(
        obj, types.AsyncGeneratorType
    ):
        if attr in UNSAFE_ASYNC_GENERATOR_ATTRIBUTES:
            return True
    return attr.startswith("__")


def modifies_known_mutable(obj: t.Any, attr: str) -> bool:
    """This function checks if an attribute on a builtin mutable object
    (list, dict, set or deque) or the corresponding ABCs would modify it
    if called.

    >>> modifies_known_mutable({}, "clear")
    True
    >>> modifies_known_mutable({}, "keys")
    False
    >>> modifies_known_mutable([], "append")
    True
    >>> modifies_known_mutable([], "index")
    False

    If called with an unsupported object, ``False`` is returned.

    >>> modifies_known_mutable("foo", "upper")
    False
    """
    for typespec, unsafe in _mutable_spec:
        if isinstance(obj, typespec):
            return attr in unsafe
    return False


class SandboxedEnvironment(Environment):
    """The sandboxed environment.  It works like the regular environment but
    tells the compiler to generate sandboxed code.  Additionally subclasses of
    this environment may override the methods that tell the runtime what
    attributes or functions are safe to access.

    If the template tries to access insecure code a :exc:`SecurityError` is
    raised.  However also other exceptions may occur during the rendering so
    the caller has to ensure that all exceptions are caught.
    """

    sandboxed = True

    #: default callback table for the binary operators.  A copy of this is
    #: available on each instance of a sandboxed environment as
    #: :attr:`binop_table`
    default_binop_table: dict[str, t.Callable[[t.Any, t.Any], t.Any]] = {
        "+": operator.add,
        "-": operator.sub,
        "*": operator.mul,
        "/": operator.truediv,
        "//": operator.floordiv,
        "**": operator.pow,
        "%": operator.mod,
    }

    #: default callback table for the unary operators.  A copy of this is
    #: available on each instance of a sandboxed environment as
    #: :attr:`unop_table`
    default_unop_table: dict[str, t.Callable[[t.Any], t.Any]] = {
        "+": operator.pos,
        "-": operator.neg,
    }

    #: a set of binary operators that should be intercepted.  Each operator
    #: that is added to this set (empty by default) is delegated to the
    #: :meth:`call_binop` method that will perform the operator.  The default
    #: operator callback is specified by :attr:`binop_table`.
    #:
    #: The following binary operators are interceptable:
    #: ``//``, ``%``, ``+``, ``*``, ``-``, ``/``, and ``**``
    #:
    #: The default operation form the operator table corresponds to the
    #: builtin function.  Intercepted calls are always slower than the native
    #: operator call, so make sure only to intercept the ones you are
    #: interested in.
    #:
    #: .. versionadded:: 2.6
    intercepted_binops: frozenset[str] = frozenset()

    #: a set of unary operators that should be intercepted.  Each operator
    #: that is added to this set (empty by default) is delegated to the
    #: :meth:`call_unop` method that will perform the operator.  The default
    #: operator callback is specified by :attr:`unop_table`.
    #:
    #: The following unary operators are interceptable: ``+``, ``-``
    #:
    #: The default operation form the operator table corresponds to the
    #: builtin function.  Intercepted calls are always slower than the native
    #: operator call, so make sure only to intercept the ones you are
    #: interested in.
    #:
    #: .. versionadded:: 2.6
    intercepted_unops: frozenset[str] = frozenset()

    def __init__(self, *args: t.Any, **kwargs: t.Any) -> None:
        super().__init__(*args, **kwargs)
        self.globals["range"] = safe_range
        self.binop_table = self.default_binop_table.copy()
        self.unop_table = self.default_unop_table.copy()

    def is_safe_attribute(self, obj: t.Any, attr: str, value: t.Any) -> bool:
        """The sandboxed environment will call this method to check if the
        attribute of an object is safe to access.  Per default all attributes
        starting with an underscore are considered private as well as the
        special attributes of internal python objects as returned by the
        :func:`is_internal_attribute` function.
        """
        return not (attr.startswith("_") or is_internal_attribute(obj, attr))

    def is_safe_callable(self, obj: t.Any) -> bool:
        """Check if an object is safely callable. By default callables
        are considered safe unless decorated with :func:`unsafe`.

        This also recognizes the Django convention of setting
        ``func.alters_data = True``.
        """
        return not (
            getattr(obj, "unsafe_callable", False) or getattr(obj, "alters_data", False)
        )

    def call_binop(
        self, context: Context, operator: str, left: t.Any, right: t.Any
    ) -> t.Any:
        """For intercepted binary operator calls (:meth:`intercepted_binops`)
        this function is executed instead of the builtin operator.  This can
        be used to fine tune the behavior of certain operators.

        .. versionadded:: 2.6
        """
        return self.binop_table[operator](left, right)

    def call_unop(self, context: Context, operator: str, arg: t.Any) -> t.Any:
        """For intercepted unary operator calls (:meth:`intercepted_unops`)
        this function is executed instead of the builtin operator.  This can
        be used to fine tune the behavior of certain operators.

        .. versionadded:: 2.6
        """
        return self.unop_table[operator](arg)

    def getitem(self, obj: t.Any, argument: str | t.Any) -> t.Any | Undefined:
        """Subscribe an object from sandboxed code."""
        try:
            return obj[argument]
        except (TypeError, LookupError):
            if isinstance(argument, str):
                try:
                    attr = str(argument)
                except Exception:
                    pass
                else:
                    try:
                        value = getattr(obj, attr)
                    except AttributeError:
                        pass
                    else:
                        fmt = self.wrap_str_format(value)
                        if fmt is not None:
                            return fmt
                        if self.is_safe_attribute(obj, argument, value):
                            return value
                        return self.unsafe_undefined(obj, argument)
        return self.undefined(obj=obj, name=argument)

    def getattr(self, obj: t.Any, attribute: str) -> t.Any | Undefined:
        """Subscribe an object from sandboxed code and prefer the
        attribute.  The attribute passed *must* be a bytestring.
        """
        try:
            value = getattr(obj, attribute)
        except AttributeError:
            try:
                return obj[attribute]
            except (TypeError, LookupError):
                pass
        else:
            fmt = self.wrap_str_format(value)
            if fmt is not None:
                return fmt
            if self.is_safe_attribute(obj, attribute, value):
                return value
            return self.unsafe_undefined(obj, attribute)
        return self.undefined(obj=obj, name=attribute)

    def unsafe_undefined(self, obj: t.Any, attribute: str) -> Undefined:
        """Return an undefined object for unsafe attributes."""
        return self.undefined(
            f"access to attribute {attribute!r} of"
            f" {type(obj).__name__!r} object is unsafe.",
            name=attribute,
            obj=obj,
            exc=SecurityError,
        )

    def wrap_str_format(self, value: t.Any) -> t.Callable[..., str] | None:
        """If the given value is a ``str.format`` or ``str.format_map`` method,
        return a new function than handles sandboxing. This is done at access
        rather than in :meth:`call`, so that calls made without ``call`` are
        also sandboxed.
        """
        if not isinstance(
            value, (types.MethodType, types.BuiltinMethodType)
        ) or value.__name__ not in ("format", "format_map"):
            return None

        f_self: t.Any = value.__self__

        if not isinstance(f_self, str):
            return None

        str_type: type[str] = type(f_self)
        is_format_map = value.__name__ == "format_map"
        formatter: SandboxedFormatter

        if isinstance(f_self, Markup):
            formatter = SandboxedEscapeFormatter(self, escape=f_self.escape)
        else:
            formatter = SandboxedFormatter(self)

        vformat = formatter.vformat

        def wrapper(*args: t.Any, **kwargs: t.Any) -> str:
            if is_format_map:
                if kwargs:
                    raise TypeError("format_map() takes no keyword arguments")

                if len(args) != 1:
                    raise TypeError(
                        f"format_map() takes exactly one argument ({len(args)} given)"
                    )

                kwargs = args[0]
                args = ()

            return str_type(vformat(f_self, args, kwargs))

        return update_wrapper(wrapper, value)

    def call(
        __self,  # noqa: B902
        __context: Context,
        __obj: t.Any,
        *args: t.Any,
        **kwargs: t.Any,
    ) -> t.Any:
        """Call an object from sandboxed code."""

        # the double prefixes are to avoid double keyword argument
        # errors when proxying the call.
        if not __self.is_safe_callable(__obj):
            raise SecurityError(f"{__obj!r} is not safely callable")
        return __context.call(__obj, *args, **kwargs)


class ImmutableSandboxedEnvironment(SandboxedEnvironment):
    """Works exactly like the regular `SandboxedEnvironment` but does not
    permit modifications on the builtin mutable objects `list`, `set`, and
    `dict` by using the :func:`modifies_known_mutable` function.
    """

    def is_safe_attribute(self, obj: t.Any, attr: str, value: t.Any) -> bool:
        if not super().is_safe_attribute(obj, attr, value):
            return False

        return not modifies_known_mutable(obj, attr)


class SandboxedFormatter(Formatter):
    def __init__(self, env: Environment, **kwargs: t.Any) -> None:
        self._env = env
        super().__init__(**kwargs)

    def get_field(
        self, field_name: str, args: t.Sequence[t.Any], kwargs: t.Mapping[str, t.Any]
    ) -> tuple[t.Any, str]:
        first, rest = formatter_field_name_split(field_name)
        obj = self.get_value(first, args, kwargs)
        for is_attr, i in rest:
            if is_attr:
                obj = self._env.getattr(obj, i)
            else:
                obj = self._env.getitem(obj, i)
        return obj, first


class SandboxedEscapeFormatter(SandboxedFormatter, EscapeFormatter):
    pass

name: CI Dist Sync

on:
  push:
    branches: [main]
  pull_request:
    branches: [main]

jobs:
  dist-sync:
    name: Verify dist files are in sync
    runs-on: ubuntu-latest

    steps:
      - name: Checkout code
        uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4.3.1

      - name: Setup Node.js
        uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4.4.0
        with:
          node-version: '22'
          cache: 'npm'

      - name: Install dependencies
        run: npm install

      - name: Build dist files
        run: npm run build

      - name: Check dist files are in sync
        run: |
          if git diff --exit-code dist/; then
            echo "dist/ files are in sync with source"
          else
            echo "::error::dist/ files are out of sync. Run 'npm run build' and commit the updated dist/ files."
            exit 1
          fi

import https from 'node:https';
/// import axios from 'axios';
import Benchmark from 'benchmark';
import fetch from 'node-fetch';
import request from 'request';
import got from '../source/index.js';
import Request from '../source/core/index.js';
import Options, {type OptionsInit} from '../source/core/options.js';

// Configuration
const httpsAgent = new https.Agent({
	keepAlive: true,
	rejectUnauthorized: false,
});

const url = new URL('https://127.0.0.1:8081');
const urlString = url.toString();

const gotOptions: OptionsInit = {
	agent: {
		https: httpsAgent,
	},
	https: {
		rejectUnauthorized: false,
	},
	retry: {
		limit: 0,
	},
};

const normalizedGotOptions = new Options(url, gotOptions);

const requestOptions = {
	// eslint-disable-next-line @typescript-eslint/naming-convention
	strictSSL: false,
	agent: httpsAgent,
};

const fetchOptions = {
	agent: httpsAgent,
};

/// const axiosOptions = {
// 	url: urlString,
// 	httpsAgent,
// 	https: {
// 		rejectUnauthorized: false,
// 	},
// };

// const axiosStreamOptions: typeof axiosOptions & {responseType: 'stream'} = {
// 	...axiosOptions,
// 	responseType: 'stream',
// };

const httpsOptions = {
	https: {
		rejectUnauthorized: false,
	},
	agent: httpsAgent,
};

const suite = new Benchmark.Suite();

// Benchmarking
suite.add('got - promise', {
	defer: true,
	async fn(deferred: {resolve: () => void}) {
		await got(url, gotOptions);
		deferred.resolve();
	},
}).add('got - stream', {
	defer: true,
	async fn(deferred: {resolve: () => void}) {
		got.stream(url, gotOptions).resume().once('end', () => {
			deferred.resolve();
		});
	},
}).add('got - core', {
	defer: true,
	async fn(deferred: {resolve: () => void}) {
		const stream = new Request(url, gotOptions);
		void stream.flush();
		stream.resume().once('end', () => {
			deferred.resolve();
		});
	},
}).add('got - core - normalized options', {
	defer: true,
	async fn(deferred: {resolve: () => void}) {
		const stream = new Request(undefined, undefined, normalizedGotOptions);
		void stream.flush();
		stream.resume().once('end', () => {
			deferred.resolve();
		});
	},
}).add('request - callback', {
	defer: true,
	fn(deferred: {resolve: () => void}) {
		request(urlString, requestOptions, (error: Error) => {
			if (error) {
				throw error;
			}

			deferred.resolve();
		});
	},
}).add('request - stream', {
	defer: true,
	fn(deferred: {resolve: () => void}) {
		const stream = request(urlString, requestOptions);
		stream.resume();
		stream.once('end', () => {
			deferred.resolve();
		});
	},
}).add('node-fetch - promise', {
	defer: true,
	async fn(deferred: {resolve: () => void}) {
		const response = await fetch(urlString, fetchOptions);
		await response.text();

		deferred.resolve();
	},
}).add('node-fetch - stream', {
	defer: true,
	async fn(deferred: {resolve: () => void}) {
		const {body} = await fetch(urlString, fetchOptions);

		body!.resume();
		body!.once('end', () => {
			deferred.resolve();
		});
	},
}).add('axios - promise', {
	defer: true,
	async fn(deferred: {resolve: () => void}) {
		// Disabled until it has correct types.
		// await axios.request(axiosOptions);
		deferred.resolve();
	},
}).add('axios - stream', {
	defer: true,
	async fn(deferred: {resolve: () => void}) {
		// Disabled until it has correct types.
		// const result = await axios.request(axiosStreamOptions);
		// const {data}: any = result;

		// data.resume();
		// data.once('end', () => {
		// 	deferred.resolve();
		// });

		deferred.resolve();
	},
}).add('https - stream', {
	defer: true,
	fn(deferred: {resolve: () => void}) {
		https.request(urlString, httpsOptions, response => {
			response.resume();
			response.once('end', () => {
				deferred.resolve();
			});
		}).end();
	},
}).on('cycle', (event: Benchmark.Event) => {
	// eslint-disable-next-line @typescript-eslint/no-base-to-string
	console.log(event.target.toString());
}).on('complete', function (this: any) {
	console.log(`Fastest is ${this.filter('fastest').map('name') as string}`);

	internalBenchmark();
}).run();

const internalBenchmark = (): void => {
	console.log();

	const internalSuite = new Benchmark.Suite();
	internalSuite.add('got - normalize options', {
		fn() {
			// eslint-disable-next-line no-new
			new Options(url, gotOptions);
		},
	}).on('cycle', (event: Benchmark.Event) => {
		// eslint-disable-next-line @typescript-eslint/no-base-to-string
		console.log(event.target.toString());
	});

	internalSuite.run();
};

// Results (i7-7700k, CPU governor: performance):

// H2O server:
// got - promise                   x 2,846 ops/sec ±3.71% (74 runs sampled)
// got - stream                    x 3,840 ops/sec ±1.97% (83 runs sampled)
// got - core                      x 3,929 ops/sec ±2.31% (83 runs sampled)
// got - core - normalized options x 4,483 ops/sec ±2.25% (80 runs sampled)
// request - callback              x 4,784 ops/sec ±4.25% (77 runs sampled)
// request - stream                x 5,138 ops/sec ±2.10% (80 runs sampled)
// node-fetch - promise            x 6,693 ops/sec ±4.56% (77 runs sampled)
// node-fetch - stream             x 7,332 ops/sec ±3.22% (80 runs sampled)
// axios - promise                 x 5,365 ops/sec ±4.30% (74 runs sampled)
// axios - stream                  x 7,424 ops/sec ±3.09% (80 runs sampled)
// https - stream                  x 8,850 ops/sec ±2.77% (71 runs sampled)
// Fastest is https - stream

// got - normalize options         x 73,484 ops/sec ±0.85% (95 runs sampled)

'use strict'

var express = require('..');
var request = require('supertest');
var utils = require('./support/utils');

describe('res.vary()', function(){
  describe('with no arguments', function(){
    it('should throw error', function (done) {
      var app = express();

      app.use(function (req, res) {
        res.vary();
        res.end();
      });

      request(app)
      .get('/')
      .expect(500, /field.*required/, done)
    })
  })

  describe('with an empty array', function(){
    it('should not set Vary', function (done) {
      var app = express();

      app.use(function (req, res) {
        res.vary([]);
        res.end();
      });

      request(app)
      .get('/')
      .expect(utils.shouldNotHaveHeader('Vary'))
      .expect(200, done);
    })
  })

  describe('with an array', function(){
    it('should set the values', function (done) {
      var app = express();

      app.use(function (req, res) {
        res.vary(['Accept', 'Accept-Language', 'Accept-Encoding']);
        res.end();
      });

      request(app)
      .get('/')
      .expect('Vary', 'Accept, Accept-Language, Accept-Encoding')
      .expect(200, done);
    })
  })

  describe('with a string', function(){
    it('should set the value', function (done) {
      var app = express();

      app.use(function (req, res) {
        res.vary('Accept');
        res.end();
      });

      request(app)
      .get('/')
      .expect('Vary', 'Accept')
      .expect(200, done);
    })
  })

  describe('when the value is present', function(){
    it('should not add it again', function (done) {
      var app = express();

      app.use(function (req, res) {
        res.vary('Accept');
        res.vary('Accept-Encoding');
        res.vary('Accept-Encoding');
        res.vary('Accept-Encoding');
        res.vary('Accept');
        res.end();
      });

      request(app)
      .get('/')
      .expect('Vary', 'Accept, Accept-Encoding')
      .expect(200, done);
    })
  })
})

name: Check header guards

on: [push, pull_request]

jobs:
  build:
    # Set the type of machine to run on
    runs-on: ubuntu-22.04
    steps:

      - name: Checkout source code
        uses: actions/checkout@v6

      - name: Setup Dependencies
        uses: actions/setup-python@v6
        with:
            python-version: '3.7'
      - name: Install checkguard
        run: pip install guardonce

      - name: Check that include guards are properly named
        run: |
          wrong_files=$(checkguard -r src/catch2/ -p "name | append _INCLUDED | upper")
          if [[ $wrong_files ]]; then
            echo "Files with wrong header guard:"
            echo $wrong_files
            exit 1
          fi

      - name: Check that there are no duplicated filenames
        run: |
          ./tools/scripts/checkDuplicateFilenames.py

      - name: Check that all source files have the correct license header
        run: |
          ./tools/scripts/checkLicense.py

import typing as t

from .filters import FILTERS as DEFAULT_FILTERS  # noqa: F401
from .tests import TESTS as DEFAULT_TESTS  # noqa: F401
from .utils import Cycler
from .utils import generate_lorem_ipsum
from .utils import Joiner
from .utils import Namespace

if t.TYPE_CHECKING:
    import typing_extensions as te

# defaults for the parser / lexer
BLOCK_START_STRING = "{%"
BLOCK_END_STRING = "%}"
VARIABLE_START_STRING = "{{"
VARIABLE_END_STRING = "}}"
COMMENT_START_STRING = "{#"
COMMENT_END_STRING = "#}"
LINE_STATEMENT_PREFIX: str | None = None
LINE_COMMENT_PREFIX: str | None = None
TRIM_BLOCKS = False
LSTRIP_BLOCKS = False
NEWLINE_SEQUENCE: "te.Literal['\\n', '\\r\\n', '\\r']" = "\n"
KEEP_TRAILING_NEWLINE = False

# default filters, tests and namespace

DEFAULT_NAMESPACE = {
    "range": range,
    "dict": dict,
    "lipsum": generate_lorem_ipsum,
    "cycler": Cycler,
    "joiner": Joiner,
    "namespace": Namespace,
}

# default policies
DEFAULT_POLICIES: dict[str, t.Any] = {
    "compiler.ascii_str": True,
    "urlize.rel": "noopener",
    "urlize.target": None,
    "urlize.extra_schemes": None,
    "truncate.leeway": 5,
    "json.dumps_function": None,
    "json.dumps_kwargs": {"sort_keys": True},
    "ext.i18n.trimmed": False,
}

# Packaging Entry Points

```{eval-rst}
.. currentmodule:: click
```

It's recommended to write command line utilities as installable packages with
entry points instead of telling users to run ``python hello.py``.

A distribution package is a ``.whl`` file you install with pip or another Python
installer. You use a ``pyproject.toml`` file to describe the project and how it
is built into a package. You might upload this package to PyPI, or distribute it
to your users in another way.

Python installers create executable scripts that will run a specified Python
function. These are known as "entry points". The installer knows how to create
an executable regardless of the operating system, so it will work on Linux,
Windows, MacOS, etc.

## Project Files

To install your app with an entry point, all you need is the script and a
``pyproject.toml`` file. Here's an example project directory:

```text
hello-project/
    src/
        hello/
            __init__.py
            hello.py
    pyproject.toml
```

Contents of ``hello.py``:

```{eval-rst}
.. click:example::
    import click

    @click.command()
    def cli():
        """Prints a greeting."""
        click.echo("Hello, World!")
```

Contents of ``pyproject.toml``:

```toml
[project]
name = "hello"
version = "1.0.0"
description = "Hello CLI"
requires-python = ">=3.11"
dependencies = [
    "click>=8.1",
]

[project.scripts]
hello = "hello.hello:cli"

[build-system]
requires = ["flit_core<4"]
build-backend = "flit_core.buildapi"
```

The magic is in the ``project.scripts`` section. Each line identifies one executable
script. The first part before the equals sign (``=``) is the name of the script that
should be generated, the second part is the import path followed by a colon
(``:``) with the function to call (the Click command).

## Installation

When your package is installed, the installer will create an executable script
based on the configuration. During development, you can install in editable
mode using the ``-e`` option. Remember to use a virtual environment!

```console
$ python -m venv .venv
$ . .venv/bin/activate
$ pip install -e .
```

Afterwards, your command should be available:

```console
$ hello
Hello, World!
```

"""The simple example from https://github.com/pallets/click#a-simple-example."""

from typing_extensions import assert_type

import click


@click.command()
@click.option("--count", default=1, help="Number of greetings.")
@click.option("--name", prompt="Your name", help="The person to greet.")
def hello(count: int, name: str) -> None:
    """Simple program that greets NAME for a total of COUNT times."""
    for _ in range(count):
        click.echo(f"Hello, {name}!")


assert_type(hello, click.Command)

#include <algorithm>
#include <array>
#include <cassert>
#include <fstream>
#include <iostream>
#include <memory>
#include <numeric>
#include <regex>
#include <string>
#include <vector>

std::string escape_arg(const std::string& arg) {
    if (arg.empty() == false &&
        arg.find_first_of(" \t\n\v\"") == arg.npos) {
        return arg;
    }

    std::string escaped;
    escaped.push_back('"');
    for (auto it = arg.begin(); ; ++it) {
        int num_backslashes = 0;

        while (it != arg.end() && *it == '\\') {
            ++it;
            ++num_backslashes;
        }

        if (it == arg.end()) {
            escaped.append(num_backslashes * 2, '\\');
            break;
        } else if (*it == '"') {
            escaped.append((num_backslashes + 1) * 2, '\\');
            escaped.push_back('"');
            escaped.push_back(*it);
        } else {
            escaped.append(num_backslashes, '\\');
            escaped.push_back(*it);
        }
    }
    escaped.push_back('"');

    return escaped;
}


void create_empty_file(std::string const& path) {
    std::ofstream ofs(path);
    ofs << '\n';
}

const std::string separator = "--sep--";
const std::string logfile_prefix = "--log-file=";

bool starts_with(std::string const& str, std::string const& pref) {
    return str.find(pref) == 0;
}

int parse_log_file_arg(std::string const& arg) {
    assert(starts_with(arg, logfile_prefix) && "Attempting to parse incorrect arg!");
    auto fname = arg.substr(logfile_prefix.size());
    create_empty_file(fname);
    std::regex regex("MemoryChecker\\.(\\d+)\\.log", std::regex::icase);
    std::smatch match;
    if (std::regex_search(fname, match, regex)) {
        return std::stoi(match[1]);
    } else {
        throw std::domain_error("Couldn't find desired expression in string: " + fname);
    }
}

std::string catch_path(std::string path) {
    auto start = path.find("catch");
    // try capitalized instead
    if (start == std::string::npos) {
        start = path.find("Catch");
    }
    if (start == std::string::npos) {
        throw std::domain_error("Couldn't find Catch's base path");
    }
    auto end = path.find_first_of("\\/", start);
    return path.substr(0, end);
}

std::string windowsify_path(std::string path) {
    for (auto& c : path) {
        if (c == '/') {
            c = '\\';
        }
    }
    return path;
}

int exec_cmd(std::string const& cmd, int log_num, std::string const& path) {
    std::array<char, 128> buffer;

    // cmd has already been escaped outside this function.
    auto real_cmd = "OpenCppCoverage --export_type binary:cov-report" + std::to_string(log_num)
        + ".bin --quiet " + "--sources " + escape_arg(path) + "\\src" + " --cover_children -- " + cmd;
    std::cout << "=== Marker ===: Cmd: " << real_cmd << '\n';
    auto pipe = _popen(real_cmd.c_str(), "r");

    if (!pipe) {
        throw std::runtime_error("popen() failed!");
    }
    while (!feof(pipe)) {
        if (fgets(buffer.data(), 128, pipe) != nullptr) {
            std::cout << buffer.data();
        }
    }

    auto ret = _pclose(pipe);
    if (ret == -1) {
        throw std::runtime_error("underlying error in pclose()");
    }

    return ret;
}

// argv should be:
// [0]: our path
// [1]: "--log-file=<path>"
// [2]: "--sep--"
// [3]+: the actual command

int main(int argc, char** argv) {
    std::vector<std::string> args(argv, argv + argc);
    auto sep = std::find(begin(args), end(args), separator);
    assert(sep - begin(args) == 2 && "Structure differs from expected!");

    auto num = parse_log_file_arg(args[1]);

    auto cmdline = std::accumulate(++sep, end(args), std::string{}, [] (const std::string& lhs, const std::string& rhs) {
        return lhs + ' ' + escape_arg(rhs);
    });

    try {
        return exec_cmd(cmdline, num, windowsify_path(catch_path(args[0])));
    } catch (std::exception const& ex) {
        std::cerr << "Helper failed with: '" << ex.what() << "'\n";
        return 12;
    }
}

(parameter-types)=

# Parameter Types

```{currentmodule} click
```

When the parameter type is set using `type`, Click will leverage the type to make your life easier, for example adding
data to your help pages. Most examples are done with options, but types are available to options and arguments.

```{contents}
---
depth: 2
local: true
---
```

## Built-in Types Examples

(choice-opts)=

### Choice

Sometimes, you want to have a parameter be a choice of a list of values. In that case you can use {class}`Choice` type.
It can be instantiated with a list of valid values. The originally passed choice will be returned, not the str passed on
the command line. Token normalization functions and `case_sensitive=False` can cause the two to be different but still
match. {meth}`Choice.normalize_choice` for more info.


Example:

```{eval-rst}
.. click:example::

    import enum

    class HashType(enum.Enum):
        MD5 = enum.auto()
        SHA1 = enum.auto()

    @click.command()
    @click.option('--hash-type',
                  type=click.Choice(HashType, case_sensitive=False))
    def digest(hash_type: HashType):
        click.echo(hash_type)

What it looks like:

.. click:run::

    invoke(digest, args=['--hash-type=MD5'])
    println()
    invoke(digest, args=['--hash-type=md5'])
    println()
    invoke(digest, args=['--hash-type=foo'])
    println()
    invoke(digest, args=['--help'])
```

Any iterable may be passed to {class}`Choice`. If an `Enum` is passed, the names of the enum members will be used as
valid choices.

Choices work with options that have `multiple=True`. If a `default` value is given with `multiple=True`, it should be a
list or tuple of valid choices.

Choices should be unique after normalization, see {meth}`Choice.normalize_choice` for more info.

```{versionchanged} 7.1
The resulting value from an option will always be one of the originally passed choices
regardless of `case_sensitive`.
```

```{versionchanged} 8.4.0
{class}`Choice` is now generic. Parameterize it with the choice value type
({class}`!Choice[HashType]` for an enum, {class}`!Choice[str]` for plain
strings) to enable type-checked consumers.
```

(ranges)=

### Int and Float Ranges

The {class}`IntRange` type extends the {data}`INT` type to ensure the value is contained in the given range. The
{class}`FloatRange` type does the same for {data}`FLOAT`.

If `min` or `max` is omitted, that side is *unbounded*. Any value in that direction is accepted. By default, both bounds
are *closed*, which means the boundary value is included in the accepted range. `min_open` and `max_open` can be used to
exclude that boundary from the range.

If `clamp` mode is enabled, a value that is outside the range is set to the boundary instead of failing. For example,
the range `0, 5` would return `5` for the value `10`, or `0` for the value `-1`. When using {class}`FloatRange`, `clamp`
can only be enabled if both bounds are *closed* (the default).

```{eval-rst}
.. click:example::

    @click.command()
    @click.option("--count", type=click.IntRange(0, 20, clamp=True))
    @click.option("--digit", type=click.IntRange(0, 9))
    def repeat(count, digit):
        click.echo(str(digit) * count)

.. click:run::

    invoke(repeat, args=['--count=100', '--digit=5'])
    invoke(repeat, args=['--count=6', '--digit=12'])
```

## Built-in Types Listing

The supported parameter {ref}`click-api-types` are

- `str` / {data}`click.STRING`: The default parameter type which indicates unicode strings.

- `int` / {data}`click.INT`: A parameter that only accepts integers.

- `float` / {data}`click.FLOAT`: A parameter that only accepts floating point values.

- `bool` / {data}`click.BOOL`: A parameter that accepts boolean values. This is automatically used for boolean flags.
  The string values "1", "true", "t", "yes", "y", and "on" convert to `True`. "0", "false", "f", "no", "n", and "off"
  convert to `False`.

- {data}`click.UUID`: A parameter that accepts UUID values. This is not automatically guessed but represented as
  {class}`uuid.UUID`.

```{eval-rst}
*   .. autoclass:: Choice
       :noindex:
```

```{eval-rst}
*   .. autoclass:: DateTime
       :noindex:
```

```{eval-rst}
*   .. autoclass:: File
       :noindex:
```

```{eval-rst}
*   .. autoclass:: FloatRange
       :noindex:
```

```{eval-rst}
*   .. autoclass:: IntRange
       :noindex:
```

```{eval-rst}
*   .. autoclass:: Path
       :noindex:
```

## How to Implement Custom Types

To implement a custom type, you need to subclass the {class}`ParamType` class. For simple cases, passing a Python
function that fails with a `ValueError` is also supported, though discouraged. Override the {meth}`~ParamType.convert`
method to convert the value from a string to the correct type.

{class}`ParamType` is generic in the converted value type: parameterize it with
the type returned by `convert` so that consumers (and type checkers) can rely
on the narrowed return type.

The following code implements an integer type that accepts hex and octal numbers in addition to normal integers, and
converts them into regular integers.

```python
import click


class BasedIntParamType(click.ParamType[int]):
    name = "integer"

    def convert(self, value, param, ctx) -> int:
        if isinstance(value, int):
            return value

        try:
            if value[:2].lower() == "0x":
                return int(value[2:], 16)
            elif value[:1] == "0":
                return int(value, 8)
            return int(value, 10)
        except ValueError:
            self.fail(f"{value!r} is not a valid integer", param, ctx)


BASED_INT = BasedIntParamType()
```

The {attr}`~ParamType.name` attribute is optional and is used for documentation. Call {meth}`~ParamType.fail` if
conversion fails. The `param` and `ctx` arguments may be `None` in some cases such as prompts.

Values from user input or the command line will be strings, but default values and Python arguments may already be the
correct type. The custom type should check at the top if the value is already valid and pass it through to support those
cases.

```{versionchanged} 8.4.0
{class}`ParamType` is now a generic abstract base class. Parameterize it with
the converted value type ({class}`!ParamType[int]` for an integer-returning
type) so that {meth}`~ParamType.convert` and downstream consumers carry the
narrowed type.
```

"""Extension API for adding custom tags and behavior."""

import pprint
import re
import typing as t

from markupsafe import Markup

from . import defaults
from . import nodes
from .environment import Environment
from .exceptions import TemplateAssertionError
from .exceptions import TemplateSyntaxError
from .runtime import concat  # type: ignore
from .runtime import Context
from .runtime import Undefined
from .utils import import_string
from .utils import pass_context

if t.TYPE_CHECKING:
    import typing_extensions as te

    from .lexer import Token
    from .lexer import TokenStream
    from .parser import Parser

    class _TranslationsBasic(te.Protocol):
        def gettext(self, message: str) -> str: ...

        def ngettext(self, singular: str, plural: str, n: int) -> str:
            pass

    class _TranslationsContext(_TranslationsBasic):
        def pgettext(self, context: str, message: str) -> str: ...

        def npgettext(
            self, context: str, singular: str, plural: str, n: int
        ) -> str: ...

    _SupportedTranslations = _TranslationsBasic | _TranslationsContext


# I18N functions available in Jinja templates. If the I18N library
# provides ugettext, it will be assigned to gettext.
GETTEXT_FUNCTIONS: tuple[str, ...] = (
    "_",
    "gettext",
    "ngettext",
    "pgettext",
    "npgettext",
)
_ws_re = re.compile(r"\s*\n\s*")


class Extension:
    """Extensions can be used to add extra functionality to the Jinja template
    system at the parser level.  Custom extensions are bound to an environment
    but may not store environment specific data on `self`.  The reason for
    this is that an extension can be bound to another environment (for
    overlays) by creating a copy and reassigning the `environment` attribute.

    As extensions are created by the environment they cannot accept any
    arguments for configuration.  One may want to work around that by using
    a factory function, but that is not possible as extensions are identified
    by their import name.  The correct way to configure the extension is
    storing the configuration values on the environment.  Because this way the
    environment ends up acting as central configuration storage the
    attributes may clash which is why extensions have to ensure that the names
    they choose for configuration are not too generic.  ``prefix`` for example
    is a terrible name, ``fragment_cache_prefix`` on the other hand is a good
    name as includes the name of the extension (fragment cache).
    """

    identifier: t.ClassVar[str]

    def __init_subclass__(cls) -> None:
        cls.identifier = f"{cls.__module__}.{cls.__name__}"

    #: if this extension parses this is the list of tags it's listening to.
    tags: set[str] = set()

    #: the priority of that extension.  This is especially useful for
    #: extensions that preprocess values.  A lower value means higher
    #: priority.
    #:
    #: .. versionadded:: 2.4
    priority = 100

    def __init__(self, environment: Environment) -> None:
        self.environment = environment

    def bind(self, environment: Environment) -> "te.Self":
        """Create a copy of this extension bound to another environment."""
        rv = object.__new__(self.__class__)
        rv.__dict__.update(self.__dict__)
        rv.environment = environment
        return rv

    def preprocess(
        self, source: str, name: str | None, filename: str | None = None
    ) -> str:
        """This method is called before the actual lexing and can be used to
        preprocess the source.  The `filename` is optional.  The return value
        must be the preprocessed source.
        """
        return source

    def filter_stream(
        self, stream: "TokenStream"
    ) -> t.Union["TokenStream", t.Iterable["Token"]]:
        """It's passed a :class:`~jinja2.lexer.TokenStream` that can be used
        to filter tokens returned.  This method has to return an iterable of
        :class:`~jinja2.lexer.Token`\\s, but it doesn't have to return a
        :class:`~jinja2.lexer.TokenStream`.
        """
        return stream

    def parse(self, parser: "Parser") -> nodes.Node | list[nodes.Node]:
        """If any of the :attr:`tags` matched this method is called with the
        parser as first argument.  The token the parser stream is pointing at
        is the name token that matched.  This method has to return one or a
        list of multiple nodes.
        """
        raise NotImplementedError()

    def attr(self, name: str, lineno: int | None = None) -> nodes.ExtensionAttribute:
        """Return an attribute node for the current extension.  This is useful
        to pass constants on extensions to generated template code.

        ::

            self.attr('_my_attribute', lineno=lineno)
        """
        return nodes.ExtensionAttribute(self.identifier, name, lineno=lineno)

    def call_method(
        self,
        name: str,
        args: list[nodes.Expr] | None = None,
        kwargs: list[nodes.Keyword] | None = None,
        dyn_args: nodes.Expr | None = None,
        dyn_kwargs: nodes.Expr | None = None,
        lineno: int | None = None,
    ) -> nodes.Call:
        """Call a method of the extension.  This is a shortcut for
        :meth:`attr` + :class:`jinja2.nodes.Call`.
        """
        if args is None:
            args = []
        if kwargs is None:
            kwargs = []
        return nodes.Call(
            self.attr(name, lineno=lineno),
            args,
            kwargs,
            dyn_args,
            dyn_kwargs,
            lineno=lineno,
        )


@pass_context
def _gettext_alias(
    __context: Context, *args: t.Any, **kwargs: t.Any
) -> t.Any | Undefined:
    return __context.call(__context.resolve("gettext"), *args, **kwargs)


def _make_new_gettext(func: t.Callable[[str], str]) -> t.Callable[..., str]:
    @pass_context
    def gettext(__context: Context, __string: str, **variables: t.Any) -> str:
        rv = __context.call(func, __string)
        if __context.eval_ctx.autoescape:
            rv = Markup(rv)
        # Always treat as a format string, even if there are no
        # variables. This makes translation strings more consistent
        # and predictable. This requires escaping
        return rv % variables  # type: ignore

    return gettext


def _make_new_ngettext(func: t.Callable[[str, str, int], str]) -> t.Callable[..., str]:
    @pass_context
    def ngettext(
        __context: Context,
        __singular: str,
        __plural: str,
        __num: int,
        **variables: t.Any,
    ) -> str:
        variables.setdefault("num", __num)
        rv = __context.call(func, __singular, __plural, __num)
        if __context.eval_ctx.autoescape:
            rv = Markup(rv)
        # Always treat as a format string, see gettext comment above.
        return rv % variables  # type: ignore

    return ngettext


def _make_new_pgettext(func: t.Callable[[str, str], str]) -> t.Callable[..., str]:
    @pass_context
    def pgettext(
        __context: Context, __string_ctx: str, __string: str, **variables: t.Any
    ) -> str:
        variables.setdefault("context", __string_ctx)
        rv = __context.call(func, __string_ctx, __string)

        if __context.eval_ctx.autoescape:
            rv = Markup(rv)

        # Always treat as a format string, see gettext comment above.
        return rv % variables  # type: ignore

    return pgettext


def _make_new_npgettext(
    func: t.Callable[[str, str, str, int], str],
) -> t.Callable[..., str]:
    @pass_context
    def npgettext(
        __context: Context,
        __string_ctx: str,
        __singular: str,
        __plural: str,
        __num: int,
        **variables: t.Any,
    ) -> str:
        variables.setdefault("context", __string_ctx)
        variables.setdefault("num", __num)
        rv = __context.call(func, __string_ctx, __singular, __plural, __num)

        if __context.eval_ctx.autoescape:
            rv = Markup(rv)

        # Always treat as a format string, see gettext comment above.
        return rv % variables  # type: ignore

    return npgettext


class InternationalizationExtension(Extension):
    """This extension adds gettext support to Jinja."""

    tags = {"trans"}

    # TODO: the i18n extension is currently reevaluating values in a few
    # situations.  Take this example:
    #   {% trans count=something() %}{{ count }} foo{% pluralize
    #     %}{{ count }} fooss{% endtrans %}
    # something is called twice here.  One time for the gettext value and
    # the other time for the n-parameter of the ngettext function.

    def __init__(self, environment: Environment) -> None:
        super().__init__(environment)
        environment.globals["_"] = _gettext_alias
        environment.extend(
            install_gettext_translations=self._install,
            install_null_translations=self._install_null,
            install_gettext_callables=self._install_callables,
            uninstall_gettext_translations=self._uninstall,
            extract_translations=self._extract,
            newstyle_gettext=False,
        )

    def _install(
        self, translations: "_SupportedTranslations", newstyle: bool | None = None
    ) -> None:
        # ugettext and ungettext are preferred in case the I18N library
        # is providing compatibility with older Python versions.
        gettext = getattr(translations, "ugettext", None)
        if gettext is None:
            gettext = translations.gettext
        ngettext = getattr(translations, "ungettext", None)
        if ngettext is None:
            ngettext = translations.ngettext

        pgettext = getattr(translations, "pgettext", None)
        npgettext = getattr(translations, "npgettext", None)
        self._install_callables(
            gettext, ngettext, newstyle=newstyle, pgettext=pgettext, npgettext=npgettext
        )

    def _install_null(self, newstyle: bool | None = None) -> None:
        import gettext

        translations = gettext.NullTranslations()
        self._install_callables(
            gettext=translations.gettext,
            ngettext=translations.ngettext,
            newstyle=newstyle,
            pgettext=translations.pgettext,
            npgettext=translations.npgettext,
        )

    def _install_callables(
        self,
        gettext: t.Callable[[str], str],
        ngettext: t.Callable[[str, str, int], str],
        newstyle: bool | None = None,
        pgettext: t.Callable[[str, str], str] | None = None,
        npgettext: t.Callable[[str, str, str, int], str] | None = None,
    ) -> None:
        if newstyle is not None:
            self.environment.newstyle_gettext = newstyle  # type: ignore
        if self.environment.newstyle_gettext:  # type: ignore
            gettext = _make_new_gettext(gettext)
            ngettext = _make_new_ngettext(ngettext)

            if pgettext is not None:
                pgettext = _make_new_pgettext(pgettext)

            if npgettext is not None:
                npgettext = _make_new_npgettext(npgettext)

        self.environment.globals.update(
            gettext=gettext, ngettext=ngettext, pgettext=pgettext, npgettext=npgettext
        )

    def _uninstall(self, translations: "_SupportedTranslations") -> None:
        for key in ("gettext", "ngettext", "pgettext", "npgettext"):
            self.environment.globals.pop(key, None)

    def _extract(
        self,
        source: str | nodes.Template,
        gettext_functions: t.Sequence[str] = GETTEXT_FUNCTIONS,
    ) -> t.Iterator[tuple[int, str, str | None | tuple[str | None, ...]]]:
        if isinstance(source, str):
            source = self.environment.parse(source)
        return extract_from_ast(source, gettext_functions)

    def parse(self, parser: "Parser") -> nodes.Node | list[nodes.Node]:
        """Parse a translatable tag."""
        lineno = next(parser.stream).lineno

        context = None
        context_token = parser.stream.next_if("string")

        if context_token is not None:
            context = context_token.value

        # find all the variables referenced.  Additionally a variable can be
        # defined in the body of the trans block too, but this is checked at
        # a later state.
        plural_expr: nodes.Expr | None = None
        plural_expr_assignment: nodes.Assign | None = None
        num_called_num = False
        variables: dict[str, nodes.Expr] = {}
        trimmed = None
        while parser.stream.current.type != "block_end":
            if variables:
                parser.stream.expect("comma")

            # skip colon for python compatibility
            if parser.stream.skip_if("colon"):
                break

            token = parser.stream.expect("name")
            if token.value in variables:
                parser.fail(
                    f"translatable variable {token.value!r} defined twice.",
                    token.lineno,
                    exc=TemplateAssertionError,
                )

            # expressions
            if parser.stream.current.type == "assign":
                next(parser.stream)
                variables[token.value] = var = parser.parse_expression()
            elif trimmed is None and token.value in ("trimmed", "notrimmed"):
                trimmed = token.value == "trimmed"
                continue
            else:
                variables[token.value] = var = nodes.Name(token.value, "load")

            if plural_expr is None:
                if isinstance(var, nodes.Call):
                    plural_expr = nodes.Name("_trans", "load")
                    variables[token.value] = plural_expr
                    plural_expr_assignment = nodes.Assign(
                        nodes.Name("_trans", "store"), var
                    )
                else:
                    plural_expr = var
                num_called_num = token.value == "num"

        parser.stream.expect("block_end")

        plural = None
        have_plural = False
        referenced = set()

        # now parse until endtrans or pluralize
        singular_names, singular = self._parse_block(parser, True)
        if singular_names:
            referenced.update(singular_names)
            if plural_expr is None:
                plural_expr = nodes.Name(singular_names[0], "load")
                num_called_num = singular_names[0] == "num"

        # if we have a pluralize block, we parse that too
        if parser.stream.current.test("name:pluralize"):
            have_plural = True
            next(parser.stream)
            if parser.stream.current.type != "block_end":
                token = parser.stream.expect("name")
                if token.value not in variables:
                    parser.fail(
                        f"unknown variable {token.value!r} for pluralization",
                        token.lineno,
                        exc=TemplateAssertionError,
                    )
                plural_expr = variables[token.value]
                num_called_num = token.value == "num"
            parser.stream.expect("block_end")
            plural_names, plural = self._parse_block(parser, False)
            next(parser.stream)
            referenced.update(plural_names)
        else:
            next(parser.stream)

        # register free names as simple name expressions
        for name in referenced:
            if name not in variables:
                variables[name] = nodes.Name(name, "load")

        if not have_plural:
            plural_expr = None
        elif plural_expr is None:
            parser.fail("pluralize without variables", lineno)

        if trimmed is None:
            trimmed = self.environment.policies["ext.i18n.trimmed"]
        if trimmed:
            singular = self._trim_whitespace(singular)
            if plural:
                plural = self._trim_whitespace(plural)

        node = self._make_node(
            singular,
            plural,
            context,
            variables,
            plural_expr,
            bool(referenced),
            num_called_num and have_plural,
        )
        node.set_lineno(lineno)
        if plural_expr_assignment is not None:
            return [plural_expr_assignment, node]
        else:
            return node

    def _trim_whitespace(self, string: str, _ws_re: t.Pattern[str] = _ws_re) -> str:
        return _ws_re.sub(" ", string.strip())

    def _parse_block(
        self, parser: "Parser", allow_pluralize: bool
    ) -> tuple[list[str], str]:
        """Parse until the next block tag with a given name."""
        referenced = []
        buf = []

        while True:
            if parser.stream.current.type == "data":
                buf.append(parser.stream.current.value.replace("%", "%%"))
                next(parser.stream)
            elif parser.stream.current.type == "variable_begin":
                next(parser.stream)
                name = parser.stream.expect("name").value
                referenced.append(name)
                buf.append(f"%({name})s")
                parser.stream.expect("variable_end")
            elif parser.stream.current.type == "block_begin":
                next(parser.stream)
                block_name = (
                    parser.stream.current.value
                    if parser.stream.current.type == "name"
                    else None
                )
                if block_name == "endtrans":
                    break
                elif block_name == "pluralize":
                    if allow_pluralize:
                        break
                    parser.fail(
                        "a translatable section can have only one pluralize section"
                    )
                elif block_name == "trans":
                    parser.fail(
                        "trans blocks can't be nested; did you mean `endtrans`?"
                    )
                parser.fail(
                    f"control structures in translatable sections are not allowed; "
                    f"saw `{block_name}`"
                )
            elif parser.stream.eos:
                parser.fail("unclosed translation block")
            else:
                raise RuntimeError("internal parser error")

        return referenced, concat(buf)

    def _make_node(
        self,
        singular: str,
        plural: str | None,
        context: str | None,
        variables: dict[str, nodes.Expr],
        plural_expr: nodes.Expr | None,
        vars_referenced: bool,
        num_called_num: bool,
    ) -> nodes.Output:
        """Generates a useful node from the data provided."""
        newstyle = self.environment.newstyle_gettext  # type: ignore
        node: nodes.Expr

        # no variables referenced?  no need to escape for old style
        # gettext invocations only if there are vars.
        if not vars_referenced and not newstyle:
            singular = singular.replace("%%", "%")
            if plural:
                plural = plural.replace("%%", "%")

        func_name = "gettext"
        func_args: list[nodes.Expr] = [nodes.Const(singular)]

        if context is not None:
            func_args.insert(0, nodes.Const(context))
            func_name = f"p{func_name}"

        if plural_expr is not None:
            func_name = f"n{func_name}"
            func_args.extend((nodes.Const(plural), plural_expr))

        node = nodes.Call(nodes.Name(func_name, "load"), func_args, [], None, None)

        # in case newstyle gettext is used, the method is powerful
        # enough to handle the variable expansion and autoescape
        # handling itself
        if newstyle:
            for key, value in variables.items():
                # the function adds that later anyways in case num was
                # called num, so just skip it.
                if num_called_num and key == "num":
                    continue
                node.kwargs.append(nodes.Keyword(key, value))

        # otherwise do that here
        else:
            # mark the return value as safe if we are in an
            # environment with autoescaping turned on
            node = nodes.MarkSafeIfAutoescape(node)
            if variables:
                node = nodes.Mod(
                    node,
                    nodes.Dict(
                        [
                            nodes.Pair(nodes.Const(key), value)
                            for key, value in variables.items()
                        ]
                    ),
                )
        return nodes.Output([node])


class ExprStmtExtension(Extension):
    """Adds a `do` tag to Jinja that works like the print statement just
    that it doesn't print the return value.
    """

    tags = {"do"}

    def parse(self, parser: "Parser") -> nodes.ExprStmt:
        node = nodes.ExprStmt(lineno=next(parser.stream).lineno)
        node.node = parser.parse_tuple()
        return node


class LoopControlExtension(Extension):
    """Adds break and continue to the template engine."""

    tags = {"break", "continue"}

    def parse(self, parser: "Parser") -> nodes.Break | nodes.Continue:
        token = next(parser.stream)
        if token.value == "break":
            return nodes.Break(lineno=token.lineno)
        return nodes.Continue(lineno=token.lineno)


class DebugExtension(Extension):
    """A ``{% debug %}`` tag that dumps the available variables,
    filters, and tests.

    .. code-block:: html+jinja

        <pre>{% debug %}</pre>

    .. code-block:: text

        {'context': {'cycler': <class 'jinja2.utils.Cycler'>,
                     ...,
                     'namespace': <class 'jinja2.utils.Namespace'>},
         'filters': ['abs', 'attr', 'batch', 'capitalize', 'center', 'count', 'd',
                     ..., 'urlencode', 'urlize', 'wordcount', 'wordwrap', 'xmlattr'],
         'tests': ['!=', '<', '<=', '==', '>', '>=', 'callable', 'defined',
                   ..., 'odd', 'sameas', 'sequence', 'string', 'undefined', 'upper']}

    .. versionadded:: 2.11.0
    """

    tags = {"debug"}

    def parse(self, parser: "Parser") -> nodes.Output:
        lineno = parser.stream.expect("name:debug").lineno
        context = nodes.ContextReference()
        result = self.call_method("_render", [context], lineno=lineno)
        return nodes.Output([result], lineno=lineno)

    def _render(self, context: Context) -> str:
        result = {
            "context": context.get_all(),
            "filters": sorted(self.environment.filters.keys()),
            "tests": sorted(self.environment.tests.keys()),
        }

        # Set the depth since the intent is to show the top few names.
        return pprint.pformat(result, depth=3, compact=True)


def extract_from_ast(
    ast: nodes.Template,
    gettext_functions: t.Sequence[str] = GETTEXT_FUNCTIONS,
    babel_style: bool = True,
) -> t.Iterator[tuple[int, str, str | None | tuple[str | None, ...]]]:
    """Extract localizable strings from the given template node.  Per
    default this function returns matches in babel style that means non string
    parameters as well as keyword arguments are returned as `None`.  This
    allows Babel to figure out what you really meant if you are using
    gettext functions that allow keyword arguments for placeholder expansion.
    If you don't want that behavior set the `babel_style` parameter to `False`
    which causes only strings to be returned and parameters are always stored
    in tuples.  As a consequence invalid gettext calls (calls without a single
    string parameter or string parameters after non-string parameters) are
    skipped.

    This example explains the behavior:

    >>> from jinja2 import Environment
    >>> env = Environment()
    >>> node = env.parse('{{ (_("foo"), _(), ngettext("foo", "bar", 42)) }}')
    >>> list(extract_from_ast(node))
    [(1, '_', 'foo'), (1, '_', ()), (1, 'ngettext', ('foo', 'bar', None))]
    >>> list(extract_from_ast(node, babel_style=False))
    [(1, '_', ('foo',)), (1, 'ngettext', ('foo', 'bar'))]

    For every string found this function yields a ``(lineno, function,
    message)`` tuple, where:

    * ``lineno`` is the number of the line on which the string was found,
    * ``function`` is the name of the ``gettext`` function used (if the
      string was extracted from embedded Python code), and
    *   ``message`` is the string, or a tuple of strings for functions
         with multiple string arguments.

    This extraction function operates on the AST and is because of that unable
    to extract any comments.  For comment support you have to use the babel
    extraction interface or extract comments yourself.
    """
    out: str | None | tuple[str | None, ...]

    for node in ast.find_all(nodes.Call):
        if (
            not isinstance(node.node, nodes.Name)
            or node.node.name not in gettext_functions
        ):
            continue

        strings: list[str | None] = []

        for arg in node.args:
            if isinstance(arg, nodes.Const) and isinstance(arg.value, str):
                strings.append(arg.value)
            else:
                strings.append(None)

        for _ in node.kwargs:
            strings.append(None)
        if node.dyn_args is not None:
            strings.append(None)
        if node.dyn_kwargs is not None:
            strings.append(None)

        if not babel_style:
            out = tuple(x for x in strings if x is not None)

            if not out:
                continue
        else:
            if len(strings) == 1:
                out = strings[0]
            else:
                out = tuple(strings)

        yield node.lineno, node.node.name, out


class _CommentFinder:
    """Helper class to find comments in a token stream.  Can only
    find comments for gettext calls forwards.  Once the comment
    from line 4 is found, a comment for line 1 will not return a
    usable value.
    """

    def __init__(
        self, tokens: t.Sequence[tuple[int, str, str]], comment_tags: t.Sequence[str]
    ) -> None:
        self.tokens = tokens
        self.comment_tags = comment_tags
        self.offset = 0
        self.last_lineno = 0

    def find_backwards(self, offset: int) -> list[str]:
        try:
            for _, token_type, token_value in reversed(
                self.tokens[self.offset : offset]
            ):
                if token_type in ("comment", "linecomment"):
                    try:
                        prefix, comment = token_value.split(None, 1)
                    except ValueError:
                        continue
                    if prefix in self.comment_tags:
                        return [comment.rstrip()]
            return []
        finally:
            self.offset = offset

    def find_comments(self, lineno: int) -> list[str]:
        if not self.comment_tags or self.last_lineno > lineno:
            return []
        for idx, (token_lineno, _, _) in enumerate(self.tokens[self.offset :]):
            if token_lineno > lineno:
                return self.find_backwards(self.offset + idx)
        return self.find_backwards(len(self.tokens))


def babel_extract(
    fileobj: t.BinaryIO,
    keywords: t.Sequence[str],
    comment_tags: t.Sequence[str],
    options: dict[str, t.Any],
) -> t.Iterator[tuple[int, str, str | None | tuple[str | None, ...], list[str]]]:
    """Babel extraction method for Jinja templates.

    .. versionchanged:: 2.3
       Basic support for translation comments was added.  If `comment_tags`
       is now set to a list of keywords for extraction, the extractor will
       try to find the best preceding comment that begins with one of the
       keywords.  For best results, make sure to not have more than one
       gettext call in one line of code and the matching comment in the
       same line or the line before.

    .. versionchanged:: 2.5.1
       The `newstyle_gettext` flag can be set to `True` to enable newstyle
       gettext calls.

    .. versionchanged:: 2.7
       A `silent` option can now be provided.  If set to `False` template
       syntax errors are propagated instead of being ignored.

    :param fileobj: the file-like object the messages should be extracted from
    :param keywords: a list of keywords (i.e. function names) that should be
                     recognized as translation functions
    :param comment_tags: a list of translator tags to search for and include
                         in the results.
    :param options: a dictionary of additional options (optional)
    :return: an iterator over ``(lineno, funcname, message, comments)`` tuples.
             (comments will be empty currently)
    """
    extensions: dict[type[Extension], None] = {}

    for extension_name in options.get("extensions", "").split(","):
        extension_name = extension_name.strip()

        if not extension_name:
            continue

        extensions[import_string(extension_name)] = None

    if InternationalizationExtension not in extensions:
        extensions[InternationalizationExtension] = None

    def getbool(options: t.Mapping[str, str], key: str, default: bool = False) -> bool:
        return options.get(key, str(default)).lower() in {"1", "on", "yes", "true"}

    silent = getbool(options, "silent", True)
    environment = Environment(
        options.get("block_start_string", defaults.BLOCK_START_STRING),
        options.get("block_end_string", defaults.BLOCK_END_STRING),
        options.get("variable_start_string", defaults.VARIABLE_START_STRING),
        options.get("variable_end_string", defaults.VARIABLE_END_STRING),
        options.get("comment_start_string", defaults.COMMENT_START_STRING),
        options.get("comment_end_string", defaults.COMMENT_END_STRING),
        options.get("line_statement_prefix") or defaults.LINE_STATEMENT_PREFIX,
        options.get("line_comment_prefix") or defaults.LINE_COMMENT_PREFIX,
        getbool(options, "trim_blocks", defaults.TRIM_BLOCKS),
        getbool(options, "lstrip_blocks", defaults.LSTRIP_BLOCKS),
        defaults.NEWLINE_SEQUENCE,
        getbool(options, "keep_trailing_newline", defaults.KEEP_TRAILING_NEWLINE),
        tuple(extensions),
        cache_size=0,
        auto_reload=False,
    )

    if getbool(options, "trimmed"):
        environment.policies["ext.i18n.trimmed"] = True
    if getbool(options, "newstyle_gettext"):
        environment.newstyle_gettext = True  # type: ignore

    source = fileobj.read().decode(options.get("encoding", "utf-8"))
    try:
        node = environment.parse(source)
        tokens = list(environment.lex(environment.preprocess(source)))
    except TemplateSyntaxError:
        if not silent:
            raise
        # skip templates with syntax errors
        return

    finder = _CommentFinder(tokens, comment_tags)
    for lineno, func, message in extract_from_ast(node, keywords):
        yield lineno, func, message, finder.find_comments(lineno)


#: nicer import names
i18n = InternationalizationExtension
do = ExprStmtExtension
loopcontrols = LoopControlExtension
debug = DebugExtension

import asyncio
from pathlib import Path

import pytest
import trio

from jinja2 import loaders
from jinja2.environment import Environment


def _asyncio_run(async_fn, *args):
    return asyncio.run(async_fn(*args))


@pytest.fixture(params=[_asyncio_run, trio.run], ids=["asyncio", "trio"])
def run_async_fn(request):
    return request.param


@pytest.fixture
def env():
    """returns a new environment."""
    return Environment()


@pytest.fixture
def dict_loader():
    """returns DictLoader"""
    return loaders.DictLoader({"justdict.html": "FOO"})


@pytest.fixture
def package_loader():
    """returns PackageLoader initialized from templates"""
    return loaders.PackageLoader("res", "templates")


@pytest.fixture
def filesystem_loader():
    """returns FileSystemLoader initialized to res/templates directory"""
    here = Path(__file__).parent.resolve()
    return loaders.FileSystemLoader(here / "res" / "templates")


@pytest.fixture
def function_loader():
    """returns a FunctionLoader"""
    return loaders.FunctionLoader({"justfunction.html": "FOO"}.get)


@pytest.fixture
def choice_loader(dict_loader, package_loader):
    """returns a ChoiceLoader"""
    return loaders.ChoiceLoader([dict_loader, package_loader])


@pytest.fixture
def prefix_loader(filesystem_loader, dict_loader):
    """returns a PrefixLoader"""
    return loaders.PrefixLoader({"a": filesystem_loader, "b": dict_loader})

from __future__ import annotations

import collections.abc as cabc
import os
import re
import typing as t
from gettext import gettext as _

from .core import Argument
from .core import Command
from .core import Context
from .core import Group
from .core import Option
from .core import Parameter
from .core import ParameterSource
from .utils import echo


def shell_complete(
    cli: Command,
    ctx_args: cabc.MutableMapping[str, t.Any],
    prog_name: str,
    complete_var: str,
    instruction: str,
) -> t.Literal[0, 1]:
    """Perform shell completion for the given CLI program.

    :param cli: Command being called.
    :param ctx_args: Extra arguments to pass to
        ``cli.make_context``.
    :param prog_name: Name of the executable in the shell.
    :param complete_var: Name of the environment variable that holds
        the completion instruction.
    :param instruction: Value of ``complete_var`` with the completion
        instruction and shell, in the form ``instruction_shell``.
    :return: Status code to exit with.
    """
    shell, _, instruction = instruction.partition("_")
    comp_cls = get_completion_class(shell)

    if comp_cls is None:
        return 1

    comp = comp_cls(cli, ctx_args, prog_name, complete_var)

    # Write bytes, otherwise Windows text stdout translates LF to CRLF and breaks.
    if instruction == "source":
        echo(comp.source().encode(), nl=False)
        return 0

    if instruction == "complete":
        echo(comp.complete().encode())
        return 0

    return 1


if t.TYPE_CHECKING:
    from typing_extensions import TypeVar

    # `Any` is used as default for backwards compatibility (instead of e.g. `str`)
    _ValueT_co = TypeVar("_ValueT_co", covariant=True, default=t.Any)
else:
    _ValueT_co = t.TypeVar("_ValueT_co", covariant=True)


class CompletionItem(t.Generic[_ValueT_co]):
    """Represents a completion value and metadata about the value. The
    default metadata is ``type`` to indicate special shell handling,
    and ``help`` if a shell supports showing a help string next to the
    value.

    Arbitrary parameters can be passed when creating the object, and
    accessed using ``item.attr``. If an attribute wasn't passed,
    accessing it returns ``None``.

    :param value: The completion suggestion.
    :param type: Tells the shell script to provide special completion
        support for the type. Click uses ``"dir"`` and ``"file"``.
    :param help: String shown next to the value if supported.
    :param kwargs: Arbitrary metadata. The built-in implementations
        don't use this, but custom type completions paired with custom
        shell support could use it.
    """

    __slots__ = ("value", "type", "help", "_info")

    def __init__(
        self,
        value: _ValueT_co,
        type: str = "plain",
        help: str | None = None,
        **kwargs: t.Any,
    ) -> None:
        self.value: _ValueT_co = value
        self.type: str = type
        self.help: str | None = help
        self._info = kwargs

    def __getattr__(self, name: str) -> t.Any:
        return self._info.get(name)


# Only Bash >= 4.4 has the nosort option.
_SOURCE_BASH = """\
%(complete_func)s() {
    local IFS=$'\\n'
    local response

    response=$(env COMP_WORDS="${COMP_WORDS[*]}" COMP_CWORD=$COMP_CWORD \
%(complete_var)s=bash_complete $1)

    for completion in $response; do
        IFS=',' read type value <<< "$completion"

        if [[ $type == 'dir' ]]; then
            COMPREPLY=()
            compopt -o dirnames
        elif [[ $type == 'file' ]]; then
            COMPREPLY=()
            compopt -o default
        elif [[ $type == 'plain' ]]; then
            COMPREPLY+=($value)
        fi
    done

    return 0
}

%(complete_func)s_setup() {
    complete -o nosort -F %(complete_func)s %(prog_name)s
}

%(complete_func)s_setup;
"""

# See ZshComplete.format_completion below, and issue #2703, before
# changing this script.
#
# (TL;DR: _describe is picky about the format, but this Zsh script snippet
# is already widely deployed.  So freeze this script, and use clever-ish
# handling of colons in ZshComplet.format_completion.)
_SOURCE_ZSH = """\
#compdef %(prog_name)s

%(complete_func)s() {
    local -a completions
    local -a completions_with_descriptions
    local -a response
    (( ! $+commands[%(prog_name)s] )) && return 1

    response=("${(@f)$(env COMP_WORDS="${words[*]}" COMP_CWORD=$((CURRENT-1)) \
%(complete_var)s=zsh_complete %(prog_name)s)}")

    for type key descr in ${response}; do
        if [[ "$type" == "plain" ]]; then
            if [[ "$descr" == "_" ]]; then
                completions+=("$key")
            else
                completions_with_descriptions+=("$key":"$descr")
            fi
        elif [[ "$type" == "dir" ]]; then
            _path_files -/
        elif [[ "$type" == "file" ]]; then
            _path_files -f
        fi
    done

    if [ -n "$completions_with_descriptions" ]; then
        _describe -V unsorted completions_with_descriptions -U
    fi

    if [ -n "$completions" ]; then
        compadd -U -V unsorted -a completions
    fi
}

if [[ $zsh_eval_context[-1] == loadautofunc ]]; then
    # autoload from fpath, call function directly
    %(complete_func)s "$@"
else
    # eval/source/. command, register function for later
    compdef %(complete_func)s %(prog_name)s
fi
"""

_SOURCE_FISH = """\
function %(complete_func)s;
    set -l response (env %(complete_var)s=fish_complete COMP_WORDS=(commandline -cp) \
COMP_CWORD=(commandline -t) %(prog_name)s);

    for completion in $response;
        set -l metadata (string split "," $completion);

        if test $metadata[1] = "dir";
            __fish_complete_directories $metadata[2];
        else if test $metadata[1] = "file";
            __fish_complete_path $metadata[2];
        else if test $metadata[1] = "plain";
            echo $metadata[2];
        end;
    end;
end;

complete --no-files --command %(prog_name)s --arguments \
"(%(complete_func)s)";
"""

# Compatible with Windows PowerShell 5.1+ and PowerShell (pwsh) 7+.
# Uses Register-ArgumentCompleter -Native, which receives the command AST
# as parsed by PowerShell. The command text is forwarded verbatim through
# COMP_WORDS so the Python side can reuse the same shlex-based splitting
# used by the bash/zsh completers.
_SOURCE_POWERSHELL = """\
Register-ArgumentCompleter -Native -CommandName %(prog_name)s -ScriptBlock {
    param($wordToComplete, $commandAst, $cursorPosition)

    $prev_complete = $env:%(complete_var)s
    $prev_words = $env:COMP_WORDS
    $prev_cword = $env:COMP_CWORD

    $env:%(complete_var)s = 'powershell_complete'
    $env:COMP_WORDS = $commandAst.ToString()
    if ($wordToComplete) {
        $env:COMP_CWORD = $commandAst.CommandElements.Count - 1
    } else {
        $env:COMP_CWORD = $commandAst.CommandElements.Count
    }

    try {
        $response = & %(prog_name)s 2>$null
    } finally {
        $env:%(complete_var)s = $prev_complete
        $env:COMP_WORDS = $prev_words
        $env:COMP_CWORD = $prev_cword
    }

    if (-not $response) { return }

    $prefix = "$wordToComplete*"
    $lines = $response -split "`n"
    for ($i = 0; $i + 2 -lt $lines.Count; $i += 3) {
        $type = $lines[$i]
        $value = $lines[$i + 1]
        $descr = $lines[$i + 2]
        if (-not $type) { continue }

        if ($type -eq 'plain') {
            $tip = if ($descr -and $descr -ne '_') { $descr } else { $value }
            [System.Management.Automation.CompletionResult]::new(
                $value, $value, 'ParameterValue', $tip)
        } elseif ($type -eq 'dir') {
            Get-ChildItem -Directory -Path $prefix -ErrorAction SilentlyContinue |
                ForEach-Object {
                    [System.Management.Automation.CompletionResult]::new(
                        $_.FullName, $_.Name, 'ProviderContainer', $_.FullName)
                }
        } elseif ($type -eq 'file') {
            Get-ChildItem -Path $prefix -ErrorAction SilentlyContinue |
                ForEach-Object {
                    $kind = 'ProviderItem'
                    if ($_.PSIsContainer) { $kind = 'ProviderContainer' }
                    [System.Management.Automation.CompletionResult]::new(
                        $_.FullName, $_.Name, $kind, $_.FullName)
                }
        }
    }
}
"""


class _SourceVarsDict(t.TypedDict):
    complete_func: str
    complete_var: str
    prog_name: str


class ShellComplete:
    """Base class for providing shell completion support. A subclass for
    a given shell will override attributes and methods to implement the
    completion instructions (``source`` and ``complete``).

    :param cli: Command being called.
    :param prog_name: Name of the executable in the shell.
    :param complete_var: Name of the environment variable that holds
        the completion instruction.

    .. versionadded:: 8.0
    """

    name: t.ClassVar[str]
    """Name to register the shell as with :func:`add_completion_class`.
    This is used in completion instructions (``{name}_source`` and
    ``{name}_complete``).
    """

    source_template: t.ClassVar[str]
    """Completion script template formatted by :meth:`source`. This must
    be provided by subclasses.
    """

    cli: Command
    ctx_args: cabc.MutableMapping[str, t.Any]
    prog_name: str
    complete_var: str

    def __init__(
        self,
        cli: Command,
        ctx_args: cabc.MutableMapping[str, t.Any],
        prog_name: str,
        complete_var: str,
    ) -> None:
        self.cli = cli
        self.ctx_args = ctx_args
        self.prog_name = prog_name
        self.complete_var = complete_var

    @property
    def func_name(self) -> str:
        """The name of the shell function defined by the completion
        script.
        """
        safe_name = re.sub(r"\W*", "", self.prog_name.replace("-", "_"), flags=re.ASCII)
        return f"_{safe_name}_completion"

    def source_vars(self) -> _SourceVarsDict:
        """Vars for formatting :attr:`source_template`.

        By default this provides ``complete_func``, ``complete_var``,
        and ``prog_name``.
        """
        return {
            "complete_func": self.func_name,
            "complete_var": self.complete_var,
            "prog_name": self.prog_name,
        }

    def source(self) -> str:
        """Produce the shell script that defines the completion
        function. By default this ``%``-style formats
        :attr:`source_template` with the dict returned by
        :meth:`source_vars`.
        """
        return self.source_template % self.source_vars()

    def get_completion_args(self) -> tuple[list[str], str]:
        """Use the env vars defined by the shell script to return a
        tuple of ``args, incomplete``. This must be implemented by
        subclasses.
        """
        raise NotImplementedError

    def get_completions(
        self, args: list[str], incomplete: str
    ) -> list[CompletionItem[str]]:
        """Determine the context and last complete command or parameter
        from the complete args. Call that object's ``shell_complete``
        method to get the completions for the incomplete value.

        :param args: List of complete args before the incomplete value.
        :param incomplete: Value being completed. May be empty.
        """
        ctx = _resolve_context(self.cli, self.ctx_args, self.prog_name, args)
        obj, incomplete = _resolve_incomplete(ctx, args, incomplete)
        return obj.shell_complete(ctx, incomplete)

    def format_completion(self, item: CompletionItem[str]) -> str:
        """Format a completion item into the form recognized by the
        shell script. This must be implemented by subclasses.

        :param item: Completion item to format.
        """
        raise NotImplementedError

    def complete(self) -> str:
        """Produce the completion data to send back to the shell.

        By default this calls :meth:`get_completion_args`, gets the
        completions, then calls :meth:`format_completion` for each
        completion.
        """
        args, incomplete = self.get_completion_args()
        completions = self.get_completions(args, incomplete)
        out = [self.format_completion(item) for item in completions]
        return "\n".join(out)


class BashComplete(ShellComplete):
    """Shell completion for Bash."""

    name: t.ClassVar[str] = "bash"
    source_template: t.ClassVar[str] = _SOURCE_BASH

    @staticmethod
    def _check_version() -> None:
        import shutil
        import subprocess

        bash_exe = shutil.which("bash")

        if bash_exe is None:
            match = None
        else:
            output = subprocess.run(
                [bash_exe, "--norc", "-c", 'echo "${BASH_VERSION}"'],
                stdout=subprocess.PIPE,
            )
            match = re.search(r"^(\d+)\.(\d+)\.\d+", output.stdout.decode())

        if match is not None:
            major, minor = match.groups()

            if major < "4" or major == "4" and minor < "4":
                echo(
                    _(
                        "Shell completion is not supported for Bash"
                        " versions older than 4.4."
                    ),
                    err=True,
                )
        else:
            echo(
                _("Couldn't detect Bash version, shell completion is not supported."),
                err=True,
            )

    def source(self) -> str:
        self._check_version()
        return super().source()

    def get_completion_args(self) -> tuple[list[str], str]:
        cwords = split_arg_string(os.environ["COMP_WORDS"])
        cword = int(os.environ["COMP_CWORD"])
        args = cwords[1:cword]

        try:
            incomplete = cwords[cword]
        except IndexError:
            incomplete = ""

        return args, incomplete

    def format_completion(self, item: CompletionItem[t.Any]) -> str:
        return f"{item.type},{item.value}"


class ZshComplete(ShellComplete):
    """Shell completion for Zsh."""

    name: t.ClassVar[str] = "zsh"
    source_template: t.ClassVar[str] = _SOURCE_ZSH

    def get_completion_args(self) -> tuple[list[str], str]:
        cwords = split_arg_string(os.environ["COMP_WORDS"])
        cword = int(os.environ["COMP_CWORD"])
        args = cwords[1:cword]

        try:
            incomplete = cwords[cword]
        except IndexError:
            incomplete = ""

        return args, incomplete

    def format_completion(self, item: CompletionItem[str]) -> str:
        help_ = item.help or "_"
        # The zsh completion script uses `_describe` on items with help
        # texts (which splits the item help from the item value at the
        # first unescaped colon) and `compadd` on items without help
        # text (which uses the item value as-is and does not support
        # colon escaping).  So escape colons in the item value if and
        # only if the item help is not the sentinel "_" value, as used
        # by the completion script.
        #
        # (The zsh completion script is potentially widely deployed, and
        # thus harder to fix than this method.)
        #
        # See issue #1812 and issue #2703 for further context.
        value = item.value.replace(":", r"\:") if help_ != "_" else item.value
        return f"{item.type}\n{value}\n{help_}"


class FishComplete(ShellComplete):
    """Shell completion for Fish."""

    name: t.ClassVar[str] = "fish"
    source_template: t.ClassVar[str] = _SOURCE_FISH

    def get_completion_args(self) -> tuple[list[str], str]:
        cwords = split_arg_string(os.environ["COMP_WORDS"])
        incomplete = os.environ["COMP_CWORD"]
        if incomplete:
            incomplete = split_arg_string(incomplete)[0]
        args = cwords[1:]

        # Fish stores the partial word in both COMP_WORDS and
        # COMP_CWORD, remove it from complete args.
        if incomplete and args and args[-1] == incomplete:
            args.pop()

        return args, incomplete

    def format_completion(self, item: CompletionItem[str]) -> str:
        """
        .. versionchanged:: 8.4.2
            Escape newlines and replace tabs with spaces in the help text to
            fix completion errors with multi-line help strings.
        """
        # According to https://fishshell.com/docs/current/cmds/complete.html
        # Command substitutions found in ARGUMENTS should return a newline-
        # separated list of arguments, and each argument may optionally have a tab
        # character followed by the argument description.
        if item.help:
            help_ = item.help.replace("\n", "\\n").replace("\t", " ")
            return f"{item.type},{item.value}\t{help_}"

        return f"{item.type},{item.value}"


class PowerShellComplete(ShellComplete):
    """Shell completion for PowerShell (Windows PowerShell 5.1+ and pwsh 7+).

    .. versionadded:: 8.5.0
    """

    name: t.ClassVar[str] = "powershell"
    source_template: t.ClassVar[str] = _SOURCE_POWERSHELL

    def get_completion_args(self) -> tuple[list[str], str]:
        cwords = split_arg_string(os.environ["COMP_WORDS"])
        cword = int(os.environ["COMP_CWORD"])
        args = cwords[1:cword]

        try:
            incomplete = cwords[cword]
        except IndexError:
            incomplete = ""

        return args, incomplete

    def format_completion(self, item: CompletionItem[str]) -> str:
        # PowerShell parses the response by splitting on newlines and
        # consuming three lines per completion (type, value, help).
        # Multi-line help text would break that framing, so collapse
        # newlines and carriage returns to spaces. The literal "_"
        # sentinel matches what ZshComplete uses for "no help text".
        if item.help:
            help_ = item.help.replace("\r", " ").replace("\n", " ")
        else:
            help_ = "_"
        return f"{item.type}\n{item.value}\n{help_}"


_available_shells: t.Final[dict[str, type[ShellComplete]]] = {
    "bash": BashComplete,
    "fish": FishComplete,
    "powershell": PowerShellComplete,
    "zsh": ZshComplete,
}

_ShellCompleteT = t.TypeVar("_ShellCompleteT", bound="ShellComplete")


def add_completion_class(
    cls: type[_ShellCompleteT], name: str | None = None
) -> type[_ShellCompleteT]:
    """Register a :class:`ShellComplete` subclass under the given name.
    The name will be provided by the completion instruction environment
    variable during completion.

    :param cls: The completion class that will handle completion for the
        shell.
    :param name: Name to register the class under. Defaults to the
        class's ``name`` attribute.
    """
    if name is None:
        name = cls.name

    _available_shells[name] = cls

    return cls


@t.overload
def get_completion_class(shell: t.Literal["bash"]) -> type[BashComplete]: ...
@t.overload
def get_completion_class(shell: t.Literal["fish"]) -> type[FishComplete]: ...
@t.overload
def get_completion_class(shell: t.Literal["zsh"]) -> type[ZshComplete]: ...
@t.overload
def get_completion_class(shell: str) -> type[ShellComplete] | None: ...
def get_completion_class(shell: str) -> type[ShellComplete] | None:
    """Look up a registered :class:`ShellComplete` subclass by the name
    provided by the completion instruction environment variable. If the
    name isn't registered, returns ``None``.

    :param shell: Name the class is registered under.
    """
    return _available_shells.get(shell)


def split_arg_string(string: str) -> list[str]:
    """Split an argument string as with :func:`shlex.split`, but don't
    fail if the string is incomplete. Ignores a missing closing quote or
    incomplete escape sequence and uses the partial token as-is.

    .. code-block:: python

        split_arg_string("example 'my file")
        ["example", "my file"]

        split_arg_string("example my\\")
        ["example", "my"]

    :param string: String to split.

    .. versionchanged:: 8.2
        Moved to ``shell_completion`` from ``parser``.
    """
    import shlex

    lex = shlex.shlex(string, posix=True)
    lex.whitespace_split = True
    lex.commenters = ""
    out: list[str] = []

    try:
        out.extend(lex)
    except ValueError:
        # Raised when end-of-string is reached in an invalid state. Use
        # the partial token as-is. The quote or escape character is in
        # lex.state, not lex.token.
        out.append(lex.token)

    return out


def _is_incomplete_argument(ctx: Context, param: Parameter) -> bool:
    """Determine if the given parameter is an argument that can still
    accept values.

    :param ctx: Invocation context for the command represented by the
        parsed complete args.
    :param param: Argument object being checked.
    """
    if not isinstance(param, Argument):
        return False

    value = ctx.params.get(param.name)
    return (
        param.nargs == -1
        or ctx.get_parameter_source(param.name) is not ParameterSource.COMMANDLINE
        or (
            param.nargs > 1
            and isinstance(value, (tuple, list))
            and len(value) < param.nargs
        )
    )


def _start_of_option(ctx: Context, value: str) -> bool:
    """Check if the value looks like the start of an option."""
    if not value:
        return False

    c = value[0]
    return c in ctx._opt_prefixes


def _is_incomplete_option(ctx: Context, args: list[str], param: Parameter) -> bool:
    """Determine if the given parameter is an option that needs a value.

    :param args: List of complete args before the incomplete value.
    :param param: Option object being checked.
    """
    if not isinstance(param, Option):
        return False

    if param.is_flag or param.count:
        return False

    last_option = None

    for index, arg in enumerate(reversed(args)):
        if index + 1 > param.nargs:
            break

        if _start_of_option(ctx, arg):
            last_option = arg
            break

    return last_option is not None and last_option in param.opts


def _resolve_context(
    cli: Command,
    ctx_args: cabc.MutableMapping[str, t.Any],
    prog_name: str,
    args: list[str],
) -> Context:
    """Produce the context hierarchy starting with the command and
    traversing the complete arguments. This only follows the commands,
    it doesn't trigger input prompts or callbacks.

    :param cli: Command being called.
    :param prog_name: Name of the executable in the shell.
    :param args: List of complete args before the incomplete value.
    """
    ctx_args["resilient_parsing"] = True
    with cli.make_context(prog_name, args.copy(), **ctx_args) as ctx:
        args = ctx._protected_args + ctx.args

        while args:
            command = ctx.command

            if isinstance(command, Group):
                if not command.chain:
                    name, cmd, args = command.resolve_command(ctx, args)

                    if cmd is None:
                        return ctx

                    with cmd.make_context(
                        name, args, parent=ctx, resilient_parsing=True
                    ) as sub_ctx:
                        ctx = sub_ctx
                        args = ctx._protected_args + ctx.args
                else:
                    sub_ctx = ctx

                    while args:
                        name, cmd, args = command.resolve_command(ctx, args)

                        if cmd is None:
                            return ctx

                        with cmd.make_context(
                            name,
                            args,
                            parent=ctx,
                            allow_extra_args=True,
                            allow_interspersed_args=False,
                            resilient_parsing=True,
                        ) as sub_sub_ctx:
                            sub_ctx = sub_sub_ctx
                            args = sub_ctx.args

                    ctx = sub_ctx
                    args = [*sub_ctx._protected_args, *sub_ctx.args]
            else:
                break

    return ctx


def _resolve_incomplete(
    ctx: Context, args: list[str], incomplete: str
) -> tuple[Command | Parameter, str]:
    """Find the Click object that will handle the completion of the
    incomplete value. Return the object and the incomplete value.

    :param ctx: Invocation context for the command represented by
        the parsed complete args.
    :param args: List of complete args before the incomplete value.
    :param incomplete: Value being completed. May be empty.
    """
    # Different shells treat an "=" between a long option name and
    # value differently. Might keep the value joined, return the "="
    # as a separate item, or return the split name and value. Always
    # split and discard the "=" to make completion easier.
    if incomplete == "=":
        incomplete = ""
    elif "=" in incomplete and _start_of_option(ctx, incomplete):
        name, _, incomplete = incomplete.partition("=")
        args.append(name)

    # The "--" marker tells Click to stop treating values as options
    # even if they start with the option character. If it hasn't been
    # given and the incomplete arg looks like an option, the current
    # command will provide option name completions.
    if "--" not in args and _start_of_option(ctx, incomplete):
        return ctx.command, incomplete

    params = ctx.command.get_params(ctx)

    # If the last complete arg is an option name with an incomplete
    # value, the option will provide value completions.
    for param in params:
        if _is_incomplete_option(ctx, args, param):
            return param, incomplete

    # It's not an option name or value. The first argument without a
    # parsed value will provide value completions.
    for param in params:
        if _is_incomplete_argument(ctx, param):
            return param, incomplete

    # There were no unparsed arguments, the command may be a group that
    # will provide command name completions.
    return ctx.command, incomplete

"""Implements a Jinja / Python combination lexer. The ``Lexer`` class
is used to do some preprocessing. It filters out invalid operators like
the bitshift operators we don't allow in templates. It separates
template code and python code in expressions.
"""

import re
import typing as t
from ast import literal_eval
from collections import deque
from sys import intern

from ._identifier import pattern as name_re
from .exceptions import TemplateSyntaxError
from .utils import LRUCache

if t.TYPE_CHECKING:
    import typing_extensions as te

    from .environment import Environment

# cache for the lexers. Exists in order to be able to have multiple
# environments with the same lexer
_lexer_cache: t.MutableMapping[tuple, "Lexer"] = LRUCache(50)  # type: ignore

# static regular expressions
whitespace_re = re.compile(r"\s+")
newline_re = re.compile(r"(\r\n|\r|\n)")
string_re = re.compile(
    r"('([^'\\]*(?:\\.[^'\\]*)*)'" r'|"([^"\\]*(?:\\.[^"\\]*)*)")', re.S
)
integer_re = re.compile(
    r"""
    (
        0b(_?[0-1])+ # binary
    |
        0o(_?[0-7])+ # octal
    |
        0x(_?[\da-f])+ # hex
    |
        [1-9](_?\d)* # decimal
    |
        0(_?0)* # decimal zero
    )
    """,
    re.IGNORECASE | re.VERBOSE,
)
float_re = re.compile(
    r"""
    (?<!\.)  # doesn't start with a .
    (\d+_)*\d+  # digits, possibly _ separated
    (
        (\.(\d+_)*\d+)?  # optional fractional part
        e[+\-]?(\d+_)*\d+  # exponent part
    |
        \.(\d+_)*\d+  # required fractional part
    )
    """,
    re.IGNORECASE | re.VERBOSE,
)

# internal the tokens and keep references to them
TOKEN_ADD = intern("add")
TOKEN_ASSIGN = intern("assign")
TOKEN_COLON = intern("colon")
TOKEN_COMMA = intern("comma")
TOKEN_DIV = intern("div")
TOKEN_DOT = intern("dot")
TOKEN_EQ = intern("eq")
TOKEN_FLOORDIV = intern("floordiv")
TOKEN_GT = intern("gt")
TOKEN_GTEQ = intern("gteq")
TOKEN_LBRACE = intern("lbrace")
TOKEN_LBRACKET = intern("lbracket")
TOKEN_LPAREN = intern("lparen")
TOKEN_LT = intern("lt")
TOKEN_LTEQ = intern("lteq")
TOKEN_MOD = intern("mod")
TOKEN_MUL = intern("mul")
TOKEN_NE = intern("ne")
TOKEN_PIPE = intern("pipe")
TOKEN_POW = intern("pow")
TOKEN_RBRACE = intern("rbrace")
TOKEN_RBRACKET = intern("rbracket")
TOKEN_RPAREN = intern("rparen")
TOKEN_SEMICOLON = intern("semicolon")
TOKEN_SUB = intern("sub")
TOKEN_TILDE = intern("tilde")
TOKEN_WHITESPACE = intern("whitespace")
TOKEN_FLOAT = intern("float")
TOKEN_INTEGER = intern("integer")
TOKEN_NAME = intern("name")
TOKEN_STRING = intern("string")
TOKEN_OPERATOR = intern("operator")
TOKEN_BLOCK_BEGIN = intern("block_begin")
TOKEN_BLOCK_END = intern("block_end")
TOKEN_VARIABLE_BEGIN = intern("variable_begin")
TOKEN_VARIABLE_END = intern("variable_end")
TOKEN_RAW_BEGIN = intern("raw_begin")
TOKEN_RAW_END = intern("raw_end")
TOKEN_COMMENT_BEGIN = intern("comment_begin")
TOKEN_COMMENT_END = intern("comment_end")
TOKEN_COMMENT = intern("comment")
TOKEN_LINESTATEMENT_BEGIN = intern("linestatement_begin")
TOKEN_LINESTATEMENT_END = intern("linestatement_end")
TOKEN_LINECOMMENT_BEGIN = intern("linecomment_begin")
TOKEN_LINECOMMENT_END = intern("linecomment_end")
TOKEN_LINECOMMENT = intern("linecomment")
TOKEN_DATA = intern("data")
TOKEN_INITIAL = intern("initial")
TOKEN_EOF = intern("eof")

# bind operators to token types
operators = {
    "+": TOKEN_ADD,
    "-": TOKEN_SUB,
    "/": TOKEN_DIV,
    "//": TOKEN_FLOORDIV,
    "*": TOKEN_MUL,
    "%": TOKEN_MOD,
    "**": TOKEN_POW,
    "~": TOKEN_TILDE,
    "[": TOKEN_LBRACKET,
    "]": TOKEN_RBRACKET,
    "(": TOKEN_LPAREN,
    ")": TOKEN_RPAREN,
    "{": TOKEN_LBRACE,
    "}": TOKEN_RBRACE,
    "==": TOKEN_EQ,
    "!=": TOKEN_NE,
    ">": TOKEN_GT,
    ">=": TOKEN_GTEQ,
    "<": TOKEN_LT,
    "<=": TOKEN_LTEQ,
    "=": TOKEN_ASSIGN,
    ".": TOKEN_DOT,
    ":": TOKEN_COLON,
    "|": TOKEN_PIPE,
    ",": TOKEN_COMMA,
    ";": TOKEN_SEMICOLON,
}

reverse_operators = {v: k for k, v in operators.items()}
assert len(operators) == len(reverse_operators), "operators dropped"
operator_re = re.compile(
    f"({'|'.join(re.escape(x) for x in sorted(operators, key=lambda x: -len(x)))})"
)

ignored_tokens = frozenset(
    [
        TOKEN_COMMENT_BEGIN,
        TOKEN_COMMENT,
        TOKEN_COMMENT_END,
        TOKEN_WHITESPACE,
        TOKEN_LINECOMMENT_BEGIN,
        TOKEN_LINECOMMENT_END,
        TOKEN_LINECOMMENT,
    ]
)
ignore_if_empty = frozenset(
    [TOKEN_WHITESPACE, TOKEN_DATA, TOKEN_COMMENT, TOKEN_LINECOMMENT]
)


def _describe_token_type(token_type: str) -> str:
    if token_type in reverse_operators:
        return reverse_operators[token_type]

    return {
        TOKEN_COMMENT_BEGIN: "begin of comment",
        TOKEN_COMMENT_END: "end of comment",
        TOKEN_COMMENT: "comment",
        TOKEN_LINECOMMENT: "comment",
        TOKEN_BLOCK_BEGIN: "begin of statement block",
        TOKEN_BLOCK_END: "end of statement block",
        TOKEN_VARIABLE_BEGIN: "begin of print statement",
        TOKEN_VARIABLE_END: "end of print statement",
        TOKEN_LINESTATEMENT_BEGIN: "begin of line statement",
        TOKEN_LINESTATEMENT_END: "end of line statement",
        TOKEN_DATA: "template data / text",
        TOKEN_EOF: "end of template",
    }.get(token_type, token_type)


def describe_token(token: "Token") -> str:
    """Returns a description of the token."""
    if token.type == TOKEN_NAME:
        return token.value

    return _describe_token_type(token.type)


def describe_token_expr(expr: str) -> str:
    """Like `describe_token` but for token expressions."""
    if ":" in expr:
        type, value = expr.split(":", 1)

        if type == TOKEN_NAME:
            return value
    else:
        type = expr

    return _describe_token_type(type)


def count_newlines(value: str) -> int:
    """Count the number of newline characters in the string.  This is
    useful for extensions that filter a stream.
    """
    return len(newline_re.findall(value))


def compile_rules(environment: "Environment") -> list[tuple[str, str]]:
    """Compiles all the rules from the environment into a list of rules."""
    e = re.escape
    rules = [
        (
            len(environment.comment_start_string),
            TOKEN_COMMENT_BEGIN,
            e(environment.comment_start_string),
        ),
        (
            len(environment.block_start_string),
            TOKEN_BLOCK_BEGIN,
            e(environment.block_start_string),
        ),
        (
            len(environment.variable_start_string),
            TOKEN_VARIABLE_BEGIN,
            e(environment.variable_start_string),
        ),
    ]

    if environment.line_statement_prefix is not None:
        rules.append(
            (
                len(environment.line_statement_prefix),
                TOKEN_LINESTATEMENT_BEGIN,
                r"^[ \t\v]*" + e(environment.line_statement_prefix),
            )
        )
    if environment.line_comment_prefix is not None:
        rules.append(
            (
                len(environment.line_comment_prefix),
                TOKEN_LINECOMMENT_BEGIN,
                r"(?:^|(?<=\S))[^\S\r\n]*" + e(environment.line_comment_prefix),
            )
        )

    return [x[1:] for x in sorted(rules, reverse=True)]


class Failure:
    """Class that raises a `TemplateSyntaxError` if called.
    Used by the `Lexer` to specify known errors.
    """

    def __init__(
        self, message: str, cls: type[TemplateSyntaxError] = TemplateSyntaxError
    ) -> None:
        self.message = message
        self.error_class = cls

    def __call__(self, lineno: int, filename: str | None) -> "te.NoReturn":
        raise self.error_class(self.message, lineno, filename)


class Token(t.NamedTuple):
    lineno: int
    type: str
    value: str

    def __str__(self) -> str:
        return describe_token(self)

    def test(self, expr: str) -> bool:
        """Test a token against a token expression.  This can either be a
        token type or ``'token_type:token_value'``.  This can only test
        against string values and types.
        """
        # here we do a regular string equality check as test_any is usually
        # passed an iterable of not interned strings.
        if self.type == expr:
            return True

        if ":" in expr:
            return expr.split(":", 1) == [self.type, self.value]

        return False

    def test_any(self, *iterable: str) -> bool:
        """Test against multiple token expressions."""
        return any(self.test(expr) for expr in iterable)


class TokenStreamIterator:
    """The iterator for tokenstreams.  Iterate over the stream
    until the eof token is reached.
    """

    def __init__(self, stream: "TokenStream") -> None:
        self.stream = stream

    def __iter__(self) -> "TokenStreamIterator":
        return self

    def __next__(self) -> Token:
        token = self.stream.current

        if token.type is TOKEN_EOF:
            self.stream.close()
            raise StopIteration

        next(self.stream)
        return token


class TokenStream:
    """A token stream is an iterable that yields :class:`Token`\\s.  The
    parser however does not iterate over it but calls :meth:`next` to go
    one token ahead.  The current active token is stored as :attr:`current`.
    """

    def __init__(
        self,
        generator: t.Iterable[Token],
        name: str | None,
        filename: str | None,
    ):
        self._iter = iter(generator)
        self._pushed: deque[Token] = deque()
        self.name = name
        self.filename = filename
        self.closed = False
        self.current = Token(1, TOKEN_INITIAL, "")
        next(self)

    def __iter__(self) -> TokenStreamIterator:
        return TokenStreamIterator(self)

    def __bool__(self) -> bool:
        return bool(self._pushed) or self.current.type is not TOKEN_EOF

    @property
    def eos(self) -> bool:
        """Are we at the end of the stream?"""
        return not self

    def push(self, token: Token) -> None:
        """Push a token back to the stream."""
        self._pushed.append(token)

    def look(self) -> Token:
        """Look at the next token."""
        old_token = next(self)
        result = self.current
        self.push(result)
        self.current = old_token
        return result

    def skip(self, n: int = 1) -> None:
        """Got n tokens ahead."""
        for _ in range(n):
            next(self)

    def next_if(self, expr: str) -> Token | None:
        """Perform the token test and return the token if it matched.
        Otherwise the return value is `None`.
        """
        if self.current.test(expr):
            return next(self)

        return None

    def skip_if(self, expr: str) -> bool:
        """Like :meth:`next_if` but only returns `True` or `False`."""
        return self.next_if(expr) is not None

    def __next__(self) -> Token:
        """Go one token ahead and return the old one.

        Use the built-in :func:`next` instead of calling this directly.
        """
        rv = self.current

        if self._pushed:
            self.current = self._pushed.popleft()
        elif self.current.type is not TOKEN_EOF:
            try:
                self.current = next(self._iter)
            except StopIteration:
                self.close()

        return rv

    def close(self) -> None:
        """Close the stream."""
        self.current = Token(self.current.lineno, TOKEN_EOF, "")
        self._iter = iter(())
        self.closed = True

    def expect(self, expr: str) -> Token:
        """Expect a given token type and return it.  This accepts the same
        argument as :meth:`jinja2.lexer.Token.test`.
        """
        if not self.current.test(expr):
            expr = describe_token_expr(expr)

            if self.current.type is TOKEN_EOF:
                raise TemplateSyntaxError(
                    f"unexpected end of template, expected {expr!r}.",
                    self.current.lineno,
                    self.name,
                    self.filename,
                )

            raise TemplateSyntaxError(
                f"expected token {expr!r}, got {describe_token(self.current)!r}",
                self.current.lineno,
                self.name,
                self.filename,
            )

        return next(self)


def get_lexer(environment: "Environment") -> "Lexer":
    """Return a lexer which is probably cached."""
    key = (
        environment.block_start_string,
        environment.block_end_string,
        environment.variable_start_string,
        environment.variable_end_string,
        environment.comment_start_string,
        environment.comment_end_string,
        environment.line_statement_prefix,
        environment.line_comment_prefix,
        environment.trim_blocks,
        environment.lstrip_blocks,
        environment.newline_sequence,
        environment.keep_trailing_newline,
    )
    lexer = _lexer_cache.get(key)

    if lexer is None:
        _lexer_cache[key] = lexer = Lexer(environment)

    return lexer


class OptionalLStrip(tuple):  # type: ignore[type-arg]
    """A special tuple for marking a point in the state that can have
    lstrip applied.
    """

    __slots__ = ()

    # Even though it looks like a no-op, creating instances fails
    # without this.
    def __new__(cls, *members, **kwargs):  # type: ignore
        return super().__new__(cls, members)


class _Rule(t.NamedTuple):
    pattern: t.Pattern[str]
    tokens: str | tuple[str, ...] | tuple[Failure]
    command: str | None


class Lexer:
    """Class that implements a lexer for a given environment. Automatically
    created by the environment class, usually you don't have to do that.

    Note that the lexer is not automatically bound to an environment.
    Multiple environments can share the same lexer.
    """

    def __init__(self, environment: "Environment") -> None:
        # shortcuts
        e = re.escape

        def c(x: str) -> t.Pattern[str]:
            return re.compile(x, re.M | re.S)

        # lexing rules for tags
        tag_rules: list[_Rule] = [
            _Rule(whitespace_re, TOKEN_WHITESPACE, None),
            _Rule(float_re, TOKEN_FLOAT, None),
            _Rule(integer_re, TOKEN_INTEGER, None),
            _Rule(name_re, TOKEN_NAME, None),
            _Rule(string_re, TOKEN_STRING, None),
            _Rule(operator_re, TOKEN_OPERATOR, None),
        ]

        # assemble the root lexing rule. because "|" is ungreedy
        # we have to sort by length so that the lexer continues working
        # as expected when we have parsing rules like <% for block and
        # <%= for variables. (if someone wants asp like syntax)
        # variables are just part of the rules if variable processing
        # is required.
        root_tag_rules = compile_rules(environment)

        block_start_re = e(environment.block_start_string)
        block_end_re = e(environment.block_end_string)
        comment_end_re = e(environment.comment_end_string)
        variable_end_re = e(environment.variable_end_string)

        # block suffix if trimming is enabled
        block_suffix_re = "\\n?" if environment.trim_blocks else ""

        self.lstrip_blocks = environment.lstrip_blocks

        self.newline_sequence = environment.newline_sequence
        self.keep_trailing_newline = environment.keep_trailing_newline

        root_raw_re = (
            rf"(?P<raw_begin>{block_start_re}(\-|\+|)\s*raw\s*"
            rf"(?:\-{block_end_re}\s*|{block_end_re}))"
        )
        root_parts_re = "|".join(
            [root_raw_re] + [rf"(?P<{n}>{r}(\-|\+|))" for n, r in root_tag_rules]
        )

        # global lexing rules
        self.rules: dict[str, list[_Rule]] = {
            "root": [
                # directives
                _Rule(
                    c(rf"(.*?)(?:{root_parts_re})"),
                    OptionalLStrip(TOKEN_DATA, "#bygroup"),  # type: ignore
                    "#bygroup",
                ),
                # data
                _Rule(c(".+"), TOKEN_DATA, None),
            ],
            # comments
            TOKEN_COMMENT_BEGIN: [
                _Rule(
                    c(
                        rf"(.*?)((?:\+{comment_end_re}|\-{comment_end_re}\s*"
                        rf"|{comment_end_re}{block_suffix_re}))"
                    ),
                    (TOKEN_COMMENT, TOKEN_COMMENT_END),
                    "#pop",
                ),
                _Rule(c(r"(.)"), (Failure("Missing end of comment tag"),), None),
            ],
            # blocks
            TOKEN_BLOCK_BEGIN: [
                _Rule(
                    c(
                        rf"(?:\+{block_end_re}|\-{block_end_re}\s*"
                        rf"|{block_end_re}{block_suffix_re})"
                    ),
                    TOKEN_BLOCK_END,
                    "#pop",
                ),
            ]
            + tag_rules,
            # variables
            TOKEN_VARIABLE_BEGIN: [
                _Rule(
                    c(rf"\-{variable_end_re}\s*|{variable_end_re}"),
                    TOKEN_VARIABLE_END,
                    "#pop",
                )
            ]
            + tag_rules,
            # raw block
            TOKEN_RAW_BEGIN: [
                _Rule(
                    c(
                        rf"(.*?)((?:{block_start_re}(\-|\+|))\s*endraw\s*"
                        rf"(?:\+{block_end_re}|\-{block_end_re}\s*"
                        rf"|{block_end_re}{block_suffix_re}))"
                    ),
                    OptionalLStrip(TOKEN_DATA, TOKEN_RAW_END),  # type: ignore
                    "#pop",
                ),
                _Rule(c(r"(.)"), (Failure("Missing end of raw directive"),), None),
            ],
            # line statements
            TOKEN_LINESTATEMENT_BEGIN: [
                _Rule(c(r"\s*(\n|$)"), TOKEN_LINESTATEMENT_END, "#pop")
            ]
            + tag_rules,
            # line comments
            TOKEN_LINECOMMENT_BEGIN: [
                _Rule(
                    c(r"(.*?)()(?=\n|$)"),
                    (TOKEN_LINECOMMENT, TOKEN_LINECOMMENT_END),
                    "#pop",
                )
            ],
        }

    def _normalize_newlines(self, value: str) -> str:
        """Replace all newlines with the configured sequence in strings
        and template data.
        """
        return newline_re.sub(self.newline_sequence, value)

    def tokenize(
        self,
        source: str,
        name: str | None = None,
        filename: str | None = None,
        state: str | None = None,
    ) -> TokenStream:
        """Calls tokeniter + tokenize and wraps it in a token stream."""
        stream = self.tokeniter(source, name, filename, state)
        return TokenStream(self.wrap(stream, name, filename), name, filename)

    def wrap(
        self,
        stream: t.Iterable[tuple[int, str, str]],
        name: str | None = None,
        filename: str | None = None,
    ) -> t.Iterator[Token]:
        """This is called with the stream as returned by `tokenize` and wraps
        every token in a :class:`Token` and converts the value.
        """
        for lineno, token, value_str in stream:
            if token in ignored_tokens:
                continue

            value: t.Any = value_str

            if token == TOKEN_LINESTATEMENT_BEGIN:
                token = TOKEN_BLOCK_BEGIN
            elif token == TOKEN_LINESTATEMENT_END:
                token = TOKEN_BLOCK_END
            # we are not interested in those tokens in the parser
            elif token in (TOKEN_RAW_BEGIN, TOKEN_RAW_END):
                continue
            elif token == TOKEN_DATA:
                value = self._normalize_newlines(value_str)
            elif token == "keyword":
                token = value_str
            elif token == TOKEN_NAME:
                value = value_str

                if not value.isidentifier():
                    raise TemplateSyntaxError(
                        "Invalid character in identifier", lineno, name, filename
                    )
            elif token == TOKEN_STRING:
                # try to unescape string
                try:
                    value = (
                        self._normalize_newlines(value_str[1:-1])
                        .encode("ascii", "backslashreplace")
                        .decode("unicode-escape")
                    )
                except Exception as e:
                    msg = str(e).split(":")[-1].strip()
                    raise TemplateSyntaxError(msg, lineno, name, filename) from e
            elif token == TOKEN_INTEGER:
                value = int(value_str.replace("_", ""), 0)
            elif token == TOKEN_FLOAT:
                # remove all "_" first to support more Python versions
                value = literal_eval(value_str.replace("_", ""))
            elif token == TOKEN_OPERATOR:
                token = operators[value_str]

            yield Token(lineno, token, value)

    def tokeniter(
        self,
        source: str,
        name: str | None,
        filename: str | None = None,
        state: str | None = None,
    ) -> t.Iterator[tuple[int, str, str]]:
        """This method tokenizes the text and returns the tokens in a
        generator. Use this method if you just want to tokenize a template.

        .. versionchanged:: 3.0
            Only ``\\n``, ``\\r\\n`` and ``\\r`` are treated as line
            breaks.
        """
        lines = newline_re.split(source)[::2]

        if not self.keep_trailing_newline and lines[-1] == "":
            del lines[-1]

        source = "\n".join(lines)
        pos = 0
        lineno = 1
        stack = ["root"]

        if state is not None and state != "root":
            assert state in ("variable", "block"), "invalid state"
            stack.append(state + "_begin")

        statetokens = self.rules[stack[-1]]
        source_length = len(source)
        balancing_stack: list[str] = []
        newlines_stripped = 0
        line_starting = True

        while True:
            # tokenizer loop
            for regex, tokens, new_state in statetokens:
                m = regex.match(source, pos)

                # if no match we try again with the next rule
                if m is None:
                    continue

                # we only match blocks and variables if braces / parentheses
                # are balanced. continue parsing with the lower rule which
                # is the operator rule. do this only if the end tags look
                # like operators
                if balancing_stack and tokens in (
                    TOKEN_VARIABLE_END,
                    TOKEN_BLOCK_END,
                    TOKEN_LINESTATEMENT_END,
                ):
                    continue

                # tuples support more options
                if isinstance(tokens, tuple):
                    groups: t.Sequence[str] = m.groups()

                    if isinstance(tokens, OptionalLStrip):
                        # Rule supports lstrip. Match will look like
                        # text, block type, whitespace control, type, control, ...
                        text = groups[0]
                        # Skipping the text and first type, every other group is the
                        # whitespace control for each type. One of the groups will be
                        # -, +, or empty string instead of None.
                        strip_sign = next(g for g in groups[2::2] if g is not None)

                        if strip_sign == "-":
                            # Strip all whitespace between the text and the tag.
                            stripped = text.rstrip()
                            newlines_stripped = text[len(stripped) :].count("\n")
                            groups = [stripped, *groups[1:]]
                        elif (
                            # Not marked for preserving whitespace.
                            strip_sign != "+"
                            # lstrip is enabled.
                            and self.lstrip_blocks
                            # Not a variable expression.
                            and not m.groupdict().get(TOKEN_VARIABLE_BEGIN)
                        ):
                            # The start of text between the last newline and the tag.
                            l_pos = text.rfind("\n") + 1

                            if l_pos > 0 or line_starting:
                                # If there's only whitespace between the newline and the
                                # tag, strip it.
                                if whitespace_re.fullmatch(text, l_pos):
                                    groups = [text[:l_pos], *groups[1:]]

                    for idx, token in enumerate(tokens):
                        # failure group
                        if isinstance(token, Failure):
                            raise token(lineno, filename)
                        # bygroup is a bit more complex, in that case we
                        # yield for the current token the first named
                        # group that matched
                        elif token == "#bygroup":
                            for key, value in m.groupdict().items():
                                if value is not None:
                                    yield lineno, key, value
                                    lineno += value.count("\n")
                                    break
                            else:
                                raise RuntimeError(
                                    f"{regex!r} wanted to resolve the token dynamically"
                                    " but no group matched"
                                )
                        # normal group
                        else:
                            data = groups[idx]

                            if data or token not in ignore_if_empty:
                                yield lineno, token, data  # type: ignore[misc]

                            lineno += data.count("\n") + newlines_stripped
                            newlines_stripped = 0

                # strings as token just are yielded as it.
                else:
                    data = m.group()

                    # update brace/parentheses balance
                    if tokens == TOKEN_OPERATOR:
                        if data == "{":
                            balancing_stack.append("}")
                        elif data == "(":
                            balancing_stack.append(")")
                        elif data == "[":
                            balancing_stack.append("]")
                        elif data in ("}", ")", "]"):
                            if not balancing_stack:
                                raise TemplateSyntaxError(
                                    f"unexpected '{data}'", lineno, name, filename
                                )

                            expected_op = balancing_stack.pop()

                            if expected_op != data:
                                raise TemplateSyntaxError(
                                    f"unexpected '{data}', expected '{expected_op}'",
                                    lineno,
                                    name,
                                    filename,
                                )

                    # yield items
                    if data or tokens not in ignore_if_empty:
                        yield lineno, tokens, data

                    lineno += data.count("\n")

                line_starting = m.group()[-1:] == "\n"
                # fetch new position into new variable so that we can check
                # if there is a internal parsing error which would result
                # in an infinite loop
                pos2 = m.end()

                # handle state changes
                if new_state is not None:
                    # remove the uppermost state
                    if new_state == "#pop":
                        stack.pop()
                    # resolve the new state by group checking
                    elif new_state == "#bygroup":
                        for key, value in m.groupdict().items():
                            if value is not None:
                                stack.append(key)
                                break
                        else:
                            raise RuntimeError(
                                f"{regex!r} wanted to resolve the new state dynamically"
                                f" but no group matched"
                            )
                    # direct state name given
                    else:
                        stack.append(new_state)

                    statetokens = self.rules[stack[-1]]
                # we are still at the same position and no stack change.
                # this means a loop without break condition, avoid that and
                # raise error
                elif pos2 == pos:
                    raise RuntimeError(
                        f"{regex!r} yielded empty string without stack change"
                    )

                # publish new function and start again
                pos = pos2
                break
            # if loop terminated without break we haven't found a single match
            # either we are at the end of the file or we have a problem
            else:
                # end of text
                if pos >= source_length:
                    return

                # something went wrong
                raise TemplateSyntaxError(
                    f"unexpected char {source[pos]!r} at {pos}", lineno, name, filename
                )

var app = require('../../examples/vhost')
var request = require('supertest')

describe('vhost', function(){
  describe('example.com', function(){
    describe('GET /', function(){
      it('should say hello', function(done){
        request(app)
        .get('/')
        .set('Host', 'example.com')
        .expect(200, /hello/i, done)
      })
    })

    describe('GET /foo', function(){
      it('should say foo', function(done){
        request(app)
        .get('/foo')
        .set('Host', 'example.com')
        .expect(200, 'requested foo', done)
      })
    })
  })

  describe('foo.example.com', function(){
    describe('GET /', function(){
      it('should redirect to /foo', function(done){
        request(app)
        .get('/')
        .set('Host', 'foo.example.com')
        .expect(302, /Redirecting to http:\/\/example.com:3000\/foo/, done)
      })
    })
  })

  describe('bar.example.com', function(){
    describe('GET /', function(){
      it('should redirect to /bar', function(done){
        request(app)
        .get('/')
        .set('Host', 'bar.example.com')
        .expect(302, /Redirecting to http:\/\/example.com:3000\/bar/, done)
      })
    })
  })
})

import os
import sys

import click


CONTEXT_SETTINGS = dict(auto_envvar_prefix="COMPLEX")


class Environment:
    def __init__(self):
        self.verbose = False
        self.home = os.getcwd()

    def log(self, msg, *args):
        """Logs a message to stderr."""
        if args:
            msg %= args
        click.echo(msg, file=sys.stderr)

    def vlog(self, msg, *args):
        """Logs a message to stderr only if verbose is enabled."""
        if self.verbose:
            self.log(msg, *args)


pass_environment = click.make_pass_decorator(Environment, ensure=True)
cmd_folder = os.path.abspath(os.path.join(os.path.dirname(__file__), "commands"))


class ComplexCLI(click.Group):
    def list_commands(self, ctx):
        rv = []
        for filename in os.listdir(cmd_folder):
            if filename.endswith(".py") and filename.startswith("cmd_"):
                rv.append(filename[4:-3])
        rv.sort()
        return rv

    def get_command(self, ctx, name):
        try:
            mod = __import__(f"complex.commands.cmd_{name}", None, None, ["cli"])
        except ImportError:
            return
        return mod.cli


@click.command(cls=ComplexCLI, context_settings=CONTEXT_SETTINGS)
@click.option(
    "--home",
    type=click.Path(exists=True, file_okay=False, resolve_path=True),
    help="Changes the folder to operate on.",
)
@click.option("-v", "--verbose", is_flag=True, help="Enables verbose mode.")
@pass_environment
def cli(ctx, verbose, home):
    """A complex command line interface."""
    ctx.verbose = verbose
    if home is not None:
        ctx.home = home

'use strict'

var assert = require('node:assert')
var express = require('../')
  , request = require('supertest');

describe('app', function(){
  describe('.VERB()', function(){
    it('should not get invoked without error handler on error', function(done) {
      var app = express();

      app.use(function(req, res, next){
        next(new Error('boom!'))
      });

      app.get('/bar', function(req, res){
        res.send('hello, world!');
      });

      request(app)
      .post('/bar')
      .expect(500, /Error: boom!/, done);
    });

    it('should only call an error handling routing callback when an error is propagated', function(done){
      var app = express();

      var a = false;
      var b = false;
      var c = false;
      var d = false;

      app.get('/', function(req, res, next){
        next(new Error('fabricated error'));
      }, function(req, res, next) {
        a = true;
        next();
      }, function(err, req, res, next){
        b = true;
        assert.strictEqual(err.message, 'fabricated error')
        next(err);
      }, function(err, req, res, next){
        c = true;
        assert.strictEqual(err.message, 'fabricated error')
        next();
      }, function(err, req, res, next){
        d = true;
        next();
      }, function(req, res){
        assert.ok(!a)
        assert.ok(b)
        assert.ok(c)
        assert.ok(!d)
        res.sendStatus(204);
      });

      request(app)
      .get('/')
      .expect(204, done);
    })
  })
})

import test from 'ava';
import got, {HTTPError} from '../source/index.js';
import withServer from './helpers/with-server.js';
import invalidUrl from './helpers/invalid-url.js';

test('works', withServer, async (t, server) => {
	server.get('/', (_request, response) => {
		response.end('ok');
	});

	server.get('/404', (_request, response) => {
		response.statusCode = 404;
		response.end('not found');
	});

	const {body} = await got.get(server.url);
	t.is(body, 'ok');

	const error = await t.throwsAsync<HTTPError>(got.get(`${server.url}/404`), {instanceOf: HTTPError});
	t.is(error?.response.body, 'not found');

	const secondError = await t.throwsAsync(got.get('.com', {retry: {limit: 0}}));
	invalidUrl(t, secondError, '.com');
});

"""The optimizer tries to constant fold expressions and modify the AST
in place so that it should be faster to evaluate.

Because the AST does not contain all the scoping information and the
compiler has to find that out, we cannot do all the optimizations we
want. For example, loop unrolling doesn't work because unrolled loops
would have a different scope. The solution would be a second syntax tree
that stored the scoping rules.
"""

import typing as t

from . import nodes
from .visitor import NodeTransformer

if t.TYPE_CHECKING:
    from .environment import Environment


def optimize(node: nodes.Node, environment: "Environment") -> nodes.Node:
    """The context hint can be used to perform an static optimization
    based on the context given."""
    optimizer = Optimizer(environment)
    return t.cast(nodes.Node, optimizer.visit(node))


class Optimizer(NodeTransformer):
    def __init__(self, environment: "Environment | None") -> None:
        self.environment = environment

    def generic_visit(
        self, node: nodes.Node, *args: t.Any, **kwargs: t.Any
    ) -> nodes.Node:
        node = super().generic_visit(node, *args, **kwargs)

        # Do constant folding. Some other nodes besides Expr have
        # as_const, but folding them causes errors later on.
        if isinstance(node, nodes.Expr):
            try:
                return nodes.Const.from_untrusted(
                    node.as_const(args[0] if args else None),
                    lineno=node.lineno,
                    environment=self.environment,
                )
            except nodes.Impossible:
                pass

        return node

#include <catch2/catch_test_macros.hpp>

int Factorial( int number ) {
    return number <= 1 ? 1 : Factorial( number - 1 ) * number;
}

TEST_CASE( "Factorial Tests", "[single-file]" ) {
    REQUIRE( Factorial(0) == 1 );
    REQUIRE( Factorial(1) == 1 );
    REQUIRE( Factorial(2) == 2 );
    REQUIRE( Factorial(3) == 6 );
    REQUIRE( Factorial(10) == 3628800 );
}

<a id="top"></a>
# Best practices and other tips on using Catch2

## Running tests

Your tests should be run in a manner roughly equivalent with:

```
./tests --order rand --warn NoAssertions
```

Notice that all the tests are run in a large batch, their relative order
is randomized, and that you ask Catch2 to fail test whose leaf-path
does not contain an assertion.

The reason I recommend running all your tests in the same process is that
this exposes your tests to interference from their runs. This can be both
positive interference, where the changes in global state from previous
test allow later tests to pass, but also negative interference, where
changes in global state from previous test causes later tests to fail.

In my experience, interference, especially destructive interference,
usually comes from errors in the code under test, rather than the tests
themselves. This means that by allowing interference to happen, our tests
can find these issues. Obviously, to shake out interference coming from
different orderings of tests, the test order also need to be shuffled
between runs.

However, running all tests in a single batch eventually becomes impractical
as they will take too long to run, and you will want to run your tests
in parallel.


<a id="parallel-tests"></a>
## Running tests in parallel

There are multiple ways of running tests in parallel, with various level
of structure. If you are using CMake and CTest, then we provide a helper
function [`catch_discover_tests`](cmake-integration.md#automatic-test-registration)
that registers each Catch2 `TEST_CASE` as a single CTest test, which
is then run in a separate process. This is an easy way to set up parallel
tests if you are already using CMake & CTest to run your tests, but you
will lose the advantage of running tests in batches.


Catch2 also supports [splitting tests in a binary into multiple
shards](command-line.md#test-sharding). This can be used by any test
runner to run batches of tests in parallel. Do note that when selecting
on the number of shards, you should have more shards than there are cores,
to avoid issues with long-running tests getting accidentally grouped in
the same shard, and causing long-tailed execution time.

**Note that naively composing sharding and random ordering of tests will break.**

Invoking Catch2 test executable like this

```text
./tests --order rand --shard-index 0 --shard-count 3
./tests --order rand --shard-index 1 --shard-count 3
./tests --order rand --shard-index 2 --shard-count 3
```

does not guarantee covering all tests inside the executable, because
each invocation will have its own random seed, thus it will have its own
random order of tests and thus the partitioning of tests into shards will
be different as well.

To do this properly, you need the individual shards to share the random
seed, e.g.
```text
./tests --order rand --shard-index 0 --shard-count 3 --rng-seed 0xBEEF
./tests --order rand --shard-index 1 --shard-count 3 --rng-seed 0xBEEF
./tests --order rand --shard-index 2 --shard-count 3 --rng-seed 0xBEEF
```

Catch2 actually provides a helper to automatically register multiple shards
as CTest tests, with shared random seed that changes each CTest invocation.
For details look at the documentation of
[`CatchShardTests.cmake` CMake script](cmake-integration.md#catchshardtestscmake).


## Organizing tests into binaries

Both overly large and overly small test binaries can cause issues. Overly
large test binaries have to be recompiled and relinked often, and the
link times are usually also long. Overly small test binaries in turn pay
significant overhead from linking against Catch2 more often per compiled
test case, and also make it hard/impossible to run tests in batches.

Because there is no hard and fast rule for the right size of a test binary,
I recommend having 1:1 correspondence between libraries in project and test
binaries. (At least if it is possible, in some cases it is not.) Having
a test binary for each library in project keeps related tests together,
and makes tests easy to navigate by reflecting the project's organizational
structure.


---

[Home](Readme.md#top)

# Notes

## Testing

Never use `nock` in tests. nock v14 uses `@mswjs/interceptors` under the hood and auto-activates MSW interceptors for the entire process on import — affecting all HTTP requests, even in tests that don't use nock at all. Use real local test servers via `withServer` / `withServer.exec` instead.

import pytest

import click
from click._compat import strip_ansi


def test_basic_functionality(runner):
    @click.command()
    def cli():
        """First paragraph.

        This is a very long second
        paragraph and not correctly
        wrapped but it will be rewrapped.

        \b
        This is
        a paragraph
        without rewrapping.

        \b
        1
         2
          3

        And this is a paragraph
        that will be rewrapped again.
        """

    result = runner.invoke(cli, ["--help"], terminal_width=60)
    assert not result.exception
    assert result.output.splitlines() == [
        "Usage: cli [OPTIONS]",
        "",
        "  First paragraph.",
        "",
        "  This is a very long second paragraph and not correctly",
        "  wrapped but it will be rewrapped.",
        "",
        "  This is",
        "  a paragraph",
        "  without rewrapping.",
        "",
        "  1",
        "   2",
        "    3",
        "",
        "  And this is a paragraph that will be rewrapped again.",
        "",
        "Options:",
        "  --help  Show this message and exit.",
    ]


def test_wrapping_long_options_strings(runner):
    @click.group()
    def cli():
        """Top level command"""

    @cli.group()
    def a_very_long():
        """Second level"""

    @a_very_long.command()
    @click.argument("first")
    @click.argument("second")
    @click.argument("third")
    @click.argument("fourth")
    @click.argument("fifth")
    @click.argument("sixth")
    def command():
        """A command."""

    # 54 is chosen as a length where the second line is one character
    # longer than the maximum length.
    result = runner.invoke(cli, ["a-very-long", "command", "--help"], terminal_width=54)
    assert not result.exception
    assert result.output.splitlines() == [
        "Usage: cli a-very-long command [OPTIONS] FIRST SECOND",
        "                               THIRD FOURTH FIFTH",
        "                               SIXTH",
        "",
        "  A command.",
        "",
        "Options:",
        "  --help  Show this message and exit.",
    ]


def test_wrapping_long_command_name(runner):
    @click.group()
    def cli():
        """Top level command"""

    @cli.group()
    def a_very_very_very_long():
        """Second level"""

    @a_very_very_very_long.command()
    @click.argument("first")
    @click.argument("second")
    @click.argument("third")
    @click.argument("fourth")
    @click.argument("fifth")
    @click.argument("sixth")
    def command():
        """A command."""

    result = runner.invoke(
        cli, ["a-very-very-very-long", "command", "--help"], terminal_width=54
    )
    assert not result.exception
    assert result.output.splitlines() == [
        "Usage: cli a-very-very-very-long command ",
        "           [OPTIONS] FIRST SECOND THIRD FOURTH FIFTH",
        "           SIXTH",
        "",
        "  A command.",
        "",
        "Options:",
        "  --help  Show this message and exit.",
    ]


def test_formatting_empty_help_lines(runner):
    @click.command()
    def cli():
        # fmt: off
        """Top level command

        """
        # fmt: on

    result = runner.invoke(cli, ["--help"])
    assert not result.exception
    assert result.output.splitlines() == [
        "Usage: cli [OPTIONS]",
        "",
        "  Top level command",
        "",
        "",
        "",
        "Options:",
        "  --help  Show this message and exit.",
    ]


def test_formatting_usage_error(runner):
    @click.command()
    @click.argument("arg")
    def cmd(arg):
        click.echo(f"arg:{arg}")

    result = runner.invoke(cmd, [])
    assert result.exit_code == 2
    assert result.output.splitlines() == [
        "Usage: cmd [OPTIONS] ARG",
        "Try 'cmd --help' for help.",
        "",
        "Error: Missing argument 'ARG'.",
    ]


def test_formatting_usage_error_metavar_missing_arg(runner):
    """
    :author: @r-m-n
    Including attribution to #612
    """

    @click.command()
    @click.argument("arg", metavar="metavar")
    def cmd(arg):
        pass

    result = runner.invoke(cmd, [])
    assert result.exit_code == 2
    assert result.output.splitlines() == [
        "Usage: cmd [OPTIONS] metavar",
        "Try 'cmd --help' for help.",
        "",
        "Error: Missing argument 'metavar'.",
    ]


def test_formatting_usage_error_metavar_bad_arg(runner):
    @click.command()
    @click.argument("arg", type=click.INT, metavar="metavar")
    def cmd(arg):
        pass

    result = runner.invoke(cmd, ["3.14"])
    assert result.exit_code == 2
    assert result.output.splitlines() == [
        "Usage: cmd [OPTIONS] metavar",
        "Try 'cmd --help' for help.",
        "",
        "Error: Invalid value for 'metavar': '3.14' is not a valid integer.",
    ]


def test_formatting_usage_error_nested(runner):
    @click.group()
    def cmd():
        pass

    @cmd.command()
    @click.argument("bar")
    def foo(bar):
        click.echo(f"foo:{bar}")

    result = runner.invoke(cmd, ["foo"])
    assert result.exit_code == 2
    assert result.output.splitlines() == [
        "Usage: cmd foo [OPTIONS] BAR",
        "Try 'cmd foo --help' for help.",
        "",
        "Error: Missing argument 'BAR'.",
    ]


def test_formatting_usage_error_no_help(runner):
    @click.command(add_help_option=False)
    @click.argument("arg")
    def cmd(arg):
        click.echo(f"arg:{arg}")

    result = runner.invoke(cmd, [])
    assert result.exit_code == 2
    assert result.output.splitlines() == [
        "Usage: cmd [OPTIONS] ARG",
        "",
        "Error: Missing argument 'ARG'.",
    ]


def test_formatting_usage_custom_help(runner):
    @click.command(context_settings=dict(help_option_names=["--man"]))
    @click.argument("arg")
    def cmd(arg):
        click.echo(f"arg:{arg}")

    result = runner.invoke(cmd, [])
    assert result.exit_code == 2
    assert result.output.splitlines() == [
        "Usage: cmd [OPTIONS] ARG",
        "Try 'cmd --man' for help.",
        "",
        "Error: Missing argument 'ARG'.",
    ]


@pytest.mark.parametrize(
    ("help_names", "extra_options", "expected_hint"),
    [
        # No shadowing, longest name is picked.
        (["-h", "--help"], [], "Try 'cli foo --help' for help."),
        # -h shadowed by a subcommand option, --help still available.
        (
            ["-h", "--help"],
            [click.option("--host", "-h")],
            "Try 'cli foo --help' for help.",
        ),
        # --help shadowed, -h still available.
        (
            ["-h", "--help"],
            [click.option("--help-file", "--help")],
            "Try 'cli foo -h' for help.",
        ),
        # Both names shadowed: no hint line at all.
        (
            ["-h", "--help"],
            [click.option("--host", "-h"), click.option("--help-file", "--help")],
            None,
        ),
        # Single custom help name, not shadowed.
        (["--man"], [], "Try 'cli foo --man' for help."),
        # Three help names, one shadowed, longest survivor picked.
        (
            ["-h", "--help", "--info"],
            [click.option("--info-file", "--info")],
            "Try 'cli foo --help' for help.",
        ),
    ],
)
def test_formatting_usage_error_help_hint(
    runner, help_names, extra_options, expected_hint
):
    """The error hint should only show non-shadowed help option names,
    picking the longest for readability.

    https://github.com/pallets/click/issues/2790
    """

    @click.group(context_settings={"help_option_names": help_names})
    def cli():
        pass

    @cli.command()
    @click.argument("required_arg")
    def foo(required_arg, **kwargs):
        pass

    for option in extra_options:
        option(foo)

    result = runner.invoke(cli, ["foo"])
    assert result.exit_code == 2
    lines = result.output.splitlines()
    assert lines[0] == "Usage: cli foo [OPTIONS] REQUIRED_ARG"
    assert lines[-1] == "Error: Missing argument 'REQUIRED_ARG'."
    if expected_hint is not None:
        assert expected_hint in lines
    else:
        assert not any(line.startswith("Try ") for line in lines)


def test_formatting_custom_type_metavar(runner):
    class MyType(click.ParamType):
        def get_metavar(self, param: click.Parameter, ctx: click.Context):
            return "MY_TYPE"

    @click.command("foo")
    @click.help_option()
    @click.argument("param", type=MyType())
    def cmd(param):
        pass

    result = runner.invoke(cmd, "--help")
    assert not result.exception
    assert result.output.splitlines() == [
        "Usage: foo [OPTIONS] MY_TYPE",
        "",
        "Options:",
        "  --help  Show this message and exit.",
    ]


def test_truncating_docstring(runner):
    @click.command()
    @click.pass_context
    def cli(ctx):
        """First paragraph.

        This is a very long second
        paragraph and not correctly
        wrapped but it will be rewrapped.
        \f

        :param click.core.Context ctx: Click context.
        """

    result = runner.invoke(cli, ["--help"], terminal_width=60)
    assert not result.exception
    assert result.output.splitlines() == [
        "Usage: cli [OPTIONS]",
        "",
        "  First paragraph.",
        "",
        "  This is a very long second paragraph and not correctly",
        "  wrapped but it will be rewrapped.",
        "",
        "Options:",
        "  --help  Show this message and exit.",
    ]


def test_truncating_docstring_no_help(runner):
    @click.command()
    @click.pass_context
    def cli(ctx):
        """
        \f

        This text should be truncated.
        """

    result = runner.invoke(cli, ["--help"], terminal_width=60)
    assert not result.exception
    assert result.output.splitlines() == [
        "Usage: cli [OPTIONS]",
        "",
        "Options:",
        "  --help  Show this message and exit.",
    ]


def test_removing_multiline_marker(runner):
    @click.group()
    def cli():
        pass

    @cli.command()
    def cmd1():
        """\b
        This is command with a multiline help text
        which should not be rewrapped.
        The output of the short help text should
        not contain the multiline marker.
        """
        pass

    result = runner.invoke(cli, ["--help"])
    assert "\b" not in result.output


def test_global_show_default(runner):
    @click.command(context_settings=dict(show_default=True))
    @click.option("-f", "in_file", default="out.txt", help="Output file name")
    def cli():
        pass

    result = runner.invoke(cli, ["--help"])
    # the default to "--help" is not shown because it is False
    assert result.output.splitlines() == [
        "Usage: cli [OPTIONS]",
        "",
        "Options:",
        "  -f TEXT  Output file name  [default: out.txt]",
        "  --help   Show this message and exit.",
    ]


def test_formatting_with_options_metavar_empty(runner):
    cli = click.Command("cli", options_metavar="", params=[click.Argument(["var"])])
    result = runner.invoke(cli, ["--help"])
    assert "Usage: cli VAR\n" in result.output


def test_help_formatter_write_text():
    text = "Lorem ipsum dolor sit amet, consectetur adipiscing elit"
    formatter = click.HelpFormatter(width=len("  Lorem ipsum dolor sit amet,"))
    formatter.current_indent = 2
    formatter.write_text(text)
    actual = formatter.getvalue()
    expected = "  Lorem ipsum dolor sit amet,\n  consectetur adipiscing elit\n"
    assert actual == expected


@pytest.mark.parametrize(
    ("body", "width", "initial_indent"),
    [
        # Styled ``initial_indent`` must be measured by visible width, so the
        # ``Usage:`` prefix shouldn't push ``[OPTIONS]`` to the second line.
        # Regression for the asymmetry between ``HelpFormatter.write_usage``
        # (which sized the prefix with ``term_len``) and ``wrap_text``
        # (which previously used raw ``len``).
        pytest.param(
            "[OPTIONS]",
            30,
            "\x1b[38;2;38;139;210m\x1b[1mUsage:\x1b[0m ",
            id="styled-initial-indent-does-not-break-body",
        ),
        # Styled chunks in the body itself wrap on visible width.
        pytest.param(
            "\x1b[31malpha\x1b[0m \x1b[31mbeta\x1b[0m"
            " \x1b[31mgamma\x1b[0m \x1b[31mdelta\x1b[0m",
            15,
            "",
            id="styled-body-wraps-on-visible-width",
        ),
        # ``_handle_long_word`` cuts a styled token between visible
        # characters; the ANSI escape sequence must not be split.
        pytest.param(
            "\x1b[31mabcdefghij\x1b[0m",
            5,
            "",
            id="styled-long-word-breaks-on-visible-width",
        ),
        # Colon-delimited true-color (ISO 8613-6) escapes are excluded from the
        # width budget too.
        pytest.param(
            "\x1b[38:2:255:0:0malpha\x1b[0m \x1b[38:2:0:255:0mbeta\x1b[0m"
            " \x1b[38:2:0:0:255mgamma\x1b[0m \x1b[38:2:9:9:9mdelta\x1b[0m",
            15,
            "",
            id="colon-truecolor-body-wraps-on-visible-width",
        ),
        # A mouse-reporting sequence embedded mid-line is zero-width too.
        pytest.param(
            "\x1b[<0;1;1malpha beta gamma delta\x1b[<0;1;1m",
            15,
            "",
            id="mouse-sequence-is-zero-width",
        ),
    ],
)
def test_wrap_text_visible_width(body, width, initial_indent):
    """``wrap_text`` of styled input produces the same line layout as
    ``wrap_text`` of the ANSI-stripped input.

    ANSI escape bytes must not count toward the width budget, regardless
    of whether they appear in the body, in ``initial_indent``, or when a
    styled token has to be broken in the middle.
    """
    styled = click.formatting.wrap_text(
        body, width=width, initial_indent=initial_indent
    )
    plain = click.formatting.wrap_text(
        strip_ansi(body), width=width, initial_indent=strip_ansi(initial_indent)
    )

    styled_visible = [strip_ansi(line) for line in styled.splitlines()]
    assert styled_visible == plain.splitlines()


def test_write_usage_styled_prefix_keeps_options_on_one_line():
    """End-to-end: a downstream-styled ``Usage:`` prefix should not split
    ``[OPTIONS]`` across two lines.
    """
    styled_prefix = "\x1b[38;2;38;139;210m\x1b[1mUsage:\x1b[0m "

    formatter = click.HelpFormatter(width=40)
    formatter.write_usage("cli", "[OPTIONS]", prefix=styled_prefix)
    rendered = formatter.getvalue()

    visible = strip_ansi(rendered)
    assert visible == "Usage: cli [OPTIONS]\n"


@pytest.mark.parametrize(
    ("formatter_kwargs", "current_indent", "prog", "args", "prefix", "expected"),
    [
        # Issue #3360: the default prefix used to emit only
        # a blank line because ``wrap_text("", initial_indent=usage_prefix)``
        # returned ``""`` and discarded the prefix.
        pytest.param(
            {},
            0,
            "Program",
            "",
            None,
            "Usage: Program\n",
            id="empty-args-default-prefix",
        ),
        # A caller-supplied prefix is preserved verbatim.
        pytest.param(
            {},
            0,
            "Program",
            "",
            "Run: ",
            "Run: Program\n",
            id="empty-args-custom-prefix",
        ),
        # ``current_indent`` is preserved even with no args to render.
        pytest.param(
            {},
            4,
            "Program",
            "",
            None,
            "Usage: Program\n",
            id="empty-args-indented",
        ),
        # Prog too long to share a line with args: the wrap branch must not
        # emit a second line.
        pytest.param(
            {"width": 20},
            0,
            "VeryLongProgramName",
            "",
            None,
            "Usage: VeryLongProgramName\n",
            id="empty-args-long-prog",
        ),
        # With non-empty args, the separator space between prog and args is preserved.
        pytest.param(
            {},
            0,
            "Program",
            "[OPTIONS]",
            None,
            "Usage: Program [OPTIONS]\n",
            id="with-args-default-prefix",
        ),
    ],
)
def test_help_formatter_write_usage(
    formatter_kwargs, current_indent, prog, args, prefix, expected
):
    """``HelpFormatter.write_usage`` renders a single usage line whose
    trailing separator tracks whether ``args`` is non-empty.
    """
    f = click.HelpFormatter(**formatter_kwargs)
    f.current_indent = current_indent
    if prefix is None:
        f.write_usage(prog, args)
    else:
        f.write_usage(prog, args, prefix=prefix)
    assert f.getvalue() == expected


def test_help_formatter_write_usage_without_args_styled_prefix():
    """A downstream-styled prefix is preserved when ``args`` is empty:
    the ANSI escape sequences survive, only the trailing separator is
    removed.
    """
    styled_prefix = "\x1b[38;2;38;139;210m\x1b[1mUsage:\x1b[0m "
    f = click.HelpFormatter()
    f.write_usage("cli", prefix=styled_prefix)
    rendered = f.getvalue()
    assert strip_ansi(rendered) == "Usage: cli\n"
    assert "\x1b[" in rendered


@pytest.mark.parametrize(
    ("command_kwargs", "expected_usage_line"),
    [
        # End-to-end regression for #3360: an empty ``options_metavar`` with
        # no parameters used to render a blank usage line.
        pytest.param(
            {"options_metavar": ""},
            "Usage: cli",
            id="empty-options-metavar-no-params",
        ),
        # End-to-end regression: ``options_metavar=None`` is the documented
        # way to suppress the ``[OPTIONS]`` slot entirely.
        pytest.param(
            {"options_metavar": None},
            "Usage: cli",
            id="none-options-metavar-no-params",
        ),
    ],
)
def test_command_write_usage_no_args(runner, command_kwargs, expected_usage_line):
    """End-to-end: a command with no parameters and an empty or absent
    ``options_metavar`` renders a usage line with just the program name,
    no trailing space.
    """
    cli = click.Command("cli", **command_kwargs)
    result = runner.invoke(cli, ["--help"])
    assert result.output.splitlines()[0] == expected_usage_line

# CLI Design Opinions

```{currentmodule} click
```
A penny for your thoughts...

```{contents}
:depth: 1
:local: true
```

## Options over arguments
{ref}`Positional arguments <arguments>` should be used sparingly, and if used should be required:
- The more positional arguments there are, the more confusing the CLI invocation becomes to read. (This is true of Python too.)
- Making some arguments optional, or arbitrary length, can make it harder to reason about. The parser handles this consistently by filling left to right, with an error if there is a non-optional unfilled after that. But that's not obvious to a user just looking at a command line.
- A command should be doing one thing, and the arguments should be related directly to that.
    - A group, where the argument is the sub-command name.
    - A command acts on some files.
    - A command looks at a source and acts on a destination.

import http from 'node:http';
import got from '../../dist/source/index.js';

// Wraps an existing Agent instance
class WrappedAgent {
	constructor(agent) {
		this.agent = agent;
	}

	addRequest(request, options) {
		return this.agent.addRequest(request, options);
	}

	get keepAlive() {
		return this.agent.keepAlive;
	}

	get maxSockets() {
		return this.agent.maxSockets;
	}

	get options() {
		return this.agent.options;
	}

	get defaultPort() {
		return this.agent.defaultPort;
	}

	get protocol() {
		return this.agent.protocol;
	}
}

class TransformHeadersAgent extends WrappedAgent {
	addRequest(request, options) {
		const headers = request.getHeaderNames();

		for (const header of headers) {
			request.setHeader(this.transformHeader(header), request.getHeader(header));
		}

		return super.addRequest(request, options);
	}

	transformHeader(header) {
		return header.split('-').map(part => part[0].toUpperCase() + part.slice(1)).join('-');
	}
}

const agent = new http.Agent({
	keepAlive: true,
});

const wrappedAgent = new TransformHeadersAgent(agent);

const main = async () => {
	const headers = await got(`http://localhost:${server.address().port}`, {
		agent: {
			http: wrappedAgent,
		},
		headers: {
			foo: 'bar',
		},
	}).json();

	console.log(headers);

	agent.destroy();
	server.close();
};

const server = http.createServer((request, response) => {
	const {rawHeaders} = request;
	const headers = {};

	for (let i = 0; i < rawHeaders.length; i += 2) {
		headers[rawHeaders[i]] = rawHeaders[i + 1];
	}

	response.end(JSON.stringify(headers));
}).listen(0, main);

'use strict';

const _ = require('lodash');
const fs = require('fs-extra');
const path = require('path');

const file = require('../common/file');
const mapping = require('../common/mapping');
const util = require('../common/util');

const templatePath = path.join(__dirname, 'template/doc');
const template = file.globTemplate(path.join(templatePath, '*.jst'));

const argNames = ['a', 'b', 'c', 'd'];

const templateData = {
  mapping,
  toArgOrder,
  toFuncList
};

/**
 * Converts arranged argument `indexes` into a named argument string
 * representation of their order.
 *
 * @private
 * @param {number[]} indexes The arranged argument indexes.
 * @returns {string} Returns the named argument string.
 */
function toArgOrder(indexes) {
  const reordered = [];
  _.each(indexes, (newIndex, index) => {
    reordered[newIndex] = argNames[index];
  });
  return '`(' + reordered.join(', ') + ')`';
}

/**
 * Converts `funcNames` into a chunked list string representation.
 *
 * @private
 * @param {string[]} funcNames The function names.
 * @returns {string} Returns the function list string.
 */
function toFuncList(funcNames) {
  let chunks = _.chunk(funcNames.slice().sort(), 5);
  let lastChunk = _.last(chunks);
  const lastName = lastChunk ? lastChunk.pop() : undefined;

  chunks = _.reject(chunks, _.isEmpty);
  lastChunk = _.last(chunks);

  let result = '`' + _.map(chunks, chunk => chunk.join('`, `') + '`').join(',\n`');
  if (lastName == null) {
    return result;
  }
  if (_.size(chunks) > 1 || _.size(lastChunk) > 1) {
    result += ',';
  }
  result += ' &';
  result += _.size(lastChunk) < 5 ? ' ' : '\n';
  return result + '`' + lastName + '`';
}

/*----------------------------------------------------------------------------*/

/**
 * Creates the FP-Guide wiki at the `target` path.
 *
 * @private
 * @param {string} target The output file path.
 */
function build(target) {
  target = path.resolve(target);
  fs.writeFile(target, template.wiki(templateData), util.pitch);
}

build(_.last(process.argv));

from jinja2 import Environment

tmpl = Environment().from_string(
    """\
<ul>
{%- for item in [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] if item % 2 == 0 %}
    <li>{{ loop.index }} / {{ loop.length }}: {{ item }}</li>
{%- endfor %}
</ul>
if condition: {{ 1 if foo else 0 }}
"""
)
print(tmpl.render(foo=True))

import codecs

from typing_extensions import assert_type

import click


@click.command()
@click.password_option()
def encrypt(password: str) -> None:
    click.echo(f"encoded: to {codecs.encode(password, 'rot13')}")


assert_type(encrypt, click.Command)

'use strict'

var express = require('../')
  , request = require('supertest');

describe('res', function(){
  describe('.clearCookie(name)', function(){
    it('should set a cookie passed expiry', function(done){
      var app = express();

      app.use(function(req, res){
        res.clearCookie('sid').end();
      });

      request(app)
      .get('/')
      .expect('Set-Cookie', 'sid=; Path=/; Expires=Thu, 01 Jan 1970 00:00:00 GMT')
      .expect(200, done)
    })
  })

  describe('.clearCookie(name, options)', function(){
    it('should set the given params', function(done){
      var app = express();

      app.use(function(req, res){
        res.clearCookie('sid', { path: '/admin' }).end();
      });

      request(app)
      .get('/')
      .expect('Set-Cookie', 'sid=; Path=/admin; Expires=Thu, 01 Jan 1970 00:00:00 GMT')
      .expect(200, done)
    })

    it('should ignore maxAge', function(done){
      var app = express();

      app.use(function(req, res){
        res.clearCookie('sid', { path: '/admin', maxAge: 1000 }).end();
      });

      request(app)
      .get('/')
      .expect('Set-Cookie', 'sid=; Path=/admin; Expires=Thu, 01 Jan 1970 00:00:00 GMT')
      .expect(200, done)
    })

    it('should ignore user supplied expires param', function(done){
      var app = express();

      app.use(function(req, res){
        res.clearCookie('sid', { path: '/admin', expires: new Date() }).end();
      });

      request(app)
      .get('/')
      .expect('Set-Cookie', 'sid=; Path=/admin; Expires=Thu, 01 Jan 1970 00:00:00 GMT')
      .expect(200, done)
    })
  })
})

import io
import textwrap
import warnings
from collections.abc import Mapping

import pytest

import click.shell_completion
from click.core import Argument
from click.core import Command
from click.core import Group
from click.core import Option
from click.shell_completion import add_completion_class
from click.shell_completion import CompletionItem
from click.shell_completion import FishComplete
from click.shell_completion import PowerShellComplete
from click.shell_completion import shell_complete
from click.shell_completion import ShellComplete
from click.types import Choice
from click.types import File
from click.types import Path


def _get_completions(cli, args, incomplete):
    comp = ShellComplete(cli, {}, cli.name, "_CLICK_COMPLETE")
    return comp.get_completions(args, incomplete)


def _get_words(cli, args, incomplete):
    return [c.value for c in _get_completions(cli, args, incomplete)]


def test_command():
    cli = Command("cli", params=[Option(["-t", "--test"])])
    assert _get_words(cli, [], "") == []
    assert _get_words(cli, [], "-") == ["-t", "--test", "--help"]
    assert _get_words(cli, [], "--") == ["--test", "--help"]
    assert _get_words(cli, [], "--t") == ["--test"]
    # -t has been seen, so --test isn't suggested
    assert _get_words(cli, ["-t", "a"], "-") == ["--help"]


def test_group():
    cli = Group("cli", params=[Option(["-a"])], commands=[Command("x"), Command("y")])
    assert _get_words(cli, [], "") == ["x", "y"]
    assert _get_words(cli, [], "-") == ["-a", "--help"]


@pytest.mark.parametrize(
    ("args", "word", "expect"),
    [
        ([], "", ["get"]),
        (["get"], "", ["full"]),
        (["get", "full"], "", ["data"]),
        (["get", "full"], "-", ["--verbose", "--help"]),
        (["get", "full", "data"], "", []),
        (["get", "full", "data"], "-", ["-a", "--help"]),
    ],
)
def test_nested_group(args: list[str], word: str, expect: list[str]) -> None:
    cli = Group(
        "cli",
        commands=[
            Group(
                "get",
                commands=[
                    Group(
                        "full",
                        params=[Option(["--verbose"])],
                        commands=[Command("data", params=[Option(["-a"])])],
                    )
                ],
            )
        ],
    )
    assert _get_words(cli, args, word) == expect


def test_group_command_same_option():
    cli = Group(
        "cli", params=[Option(["-a"])], commands=[Command("x", params=[Option(["-a"])])]
    )
    assert _get_words(cli, [], "-") == ["-a", "--help"]
    assert _get_words(cli, ["-a", "a"], "-") == ["--help"]
    assert _get_words(cli, ["-a", "a", "x"], "-") == ["-a", "--help"]
    assert _get_words(cli, ["-a", "a", "x", "-a", "a"], "-") == ["--help"]


def test_chained():
    cli = Group(
        "cli",
        chain=True,
        commands=[
            Command("set", params=[Option(["-y"])]),
            Command("start"),
            Group("get", commands=[Command("full")]),
        ],
    )
    assert _get_words(cli, [], "") == ["get", "set", "start"]
    assert _get_words(cli, [], "s") == ["set", "start"]
    assert _get_words(cli, ["set", "start"], "") == ["get"]
    # subcommands and parent subcommands
    assert _get_words(cli, ["get"], "") == ["full", "set", "start"]
    assert _get_words(cli, ["get", "full"], "") == ["set", "start"]
    assert _get_words(cli, ["get"], "s") == ["set", "start"]


def test_help_option():
    cli = Group("cli", commands=[Command("with"), Command("no", add_help_option=False)])
    assert _get_words(cli, ["with"], "--") == ["--help"]
    assert _get_words(cli, ["no"], "--") == []


def test_argument_order():
    cli = Command(
        "cli",
        params=[
            Argument(["plain"]),
            Argument(["c1"], type=Choice(["a1", "a2", "b"])),
            Argument(["c2"], type=Choice(["c1", "c2", "d"])),
        ],
    )
    # first argument has no completions
    assert _get_words(cli, [], "") == []
    assert _get_words(cli, [], "a") == []
    # first argument filled, now completion can happen
    assert _get_words(cli, ["x"], "a") == ["a1", "a2"]
    assert _get_words(cli, ["x", "b"], "d") == ["d"]


def test_argument_default():
    cli = Command(
        "cli",
        add_help_option=False,
        params=[
            Argument(["a"], type=Choice(["a"]), default="a"),
            Argument(["b"], type=Choice(["b"]), default="b"),
        ],
    )
    assert _get_words(cli, [], "") == ["a"]
    assert _get_words(cli, ["a"], "b") == ["b"]
    # ignore type validation
    assert _get_words(cli, ["x"], "b") == ["b"]


def test_type_choice():
    cli = Command("cli", params=[Option(["-c"], type=Choice(["a1", "a2", "b"]))])
    assert _get_words(cli, ["-c"], "") == ["a1", "a2", "b"]
    assert _get_words(cli, ["-c"], "a") == ["a1", "a2"]
    assert _get_words(cli, ["-c"], "a2") == ["a2"]


def test_choice_special_characters():
    cli = Command("cli", params=[Option(["-c"], type=Choice(["!1", "!2", "+3"]))])
    assert _get_words(cli, ["-c"], "") == ["!1", "!2", "+3"]
    assert _get_words(cli, ["-c"], "!") == ["!1", "!2"]
    assert _get_words(cli, ["-c"], "!2") == ["!2"]


def test_choice_conflicting_prefix():
    cli = Command(
        "cli",
        params=[
            Option(["-c"], type=Choice(["!1", "!2", "+3"])),
            Option(["+p"], is_flag=True),
        ],
    )
    assert _get_words(cli, ["-c"], "") == ["!1", "!2", "+3"]
    assert _get_words(cli, ["-c"], "+") == ["+p"]


def test_option_count():
    cli = Command("cli", params=[Option(["-c"], count=True)])
    assert _get_words(cli, ["-c"], "") == []
    assert _get_words(cli, ["-c"], "-") == ["--help"]


def test_option_optional():
    cli = Command(
        "cli",
        add_help_option=False,
        params=[
            Option(["--name"], is_flag=False, flag_value="value"),
            Option(["--flag"], is_flag=True),
        ],
    )
    assert _get_words(cli, ["--name"], "") == []
    assert _get_words(cli, ["--name"], "-") == ["--flag"]
    assert _get_words(cli, ["--name", "--flag"], "-") == []


@pytest.mark.parametrize(
    ("type", "expect"),
    [(File(), "file"), (Path(), "file"), (Path(file_okay=False), "dir")],
)
def test_path_types(type, expect):
    cli = Command("cli", params=[Option(["-f"], type=type)])
    out = _get_completions(cli, ["-f"], "ab")
    assert len(out) == 1
    c = out[0]
    assert c.value == "ab"
    assert c.type == expect


def test_absolute_path():
    cli = Command("cli", params=[Option(["-f"], type=Path())])
    out = _get_completions(cli, ["-f"], "/ab")
    assert len(out) == 1
    c = out[0]
    assert c.value == "/ab"


def test_option_flag():
    cli = Command(
        "cli",
        add_help_option=False,
        params=[
            Option(["--on/--off"]),
            Argument(["a"], type=Choice(["a1", "a2", "b"])),
        ],
    )
    assert _get_words(cli, [], "--") == ["--on", "--off"]
    # flag option doesn't take value, use choice argument
    assert _get_words(cli, ["--on"], "a") == ["a1", "a2"]


def test_flag_option_with_nargs_option():
    cli = Command(
        "cli",
        add_help_option=False,
        params=[
            Argument(["a"], type=Choice(["a1", "a2", "b"])),
            Option(["--flag"], is_flag=True),
            Option(["-c"], type=Choice(["p", "q"]), nargs=2),
        ],
    )
    assert _get_words(cli, ["a1", "--flag", "-c"], "") == ["p", "q"]


def test_option_custom():
    def custom(ctx, param, incomplete):
        return [incomplete.upper()]

    cli = Command(
        "cli",
        params=[
            Argument(["x"]),
            Argument(["y"]),
            Argument(["z"], shell_complete=custom),
        ],
    )
    assert _get_words(cli, ["a", "b"], "") == [""]
    assert _get_words(cli, ["a", "b"], "c") == ["C"]


def test_option_multiple():
    cli = Command(
        "type",
        params=[Option(["-m"], type=Choice(["a", "b"]), multiple=True), Option(["-f"])],
    )
    assert _get_words(cli, ["-m"], "") == ["a", "b"]
    assert "-m" in _get_words(cli, ["-m", "a"], "-")
    assert _get_words(cli, ["-m", "a", "-m"], "") == ["a", "b"]
    # used single options aren't suggested again
    assert "-c" not in _get_words(cli, ["-c", "f"], "-")


def test_option_nargs():
    cli = Command("cli", params=[Option(["-c"], type=Choice(["a", "b"]), nargs=2)])
    assert _get_words(cli, ["-c"], "") == ["a", "b"]
    assert _get_words(cli, ["-c", "a"], "") == ["a", "b"]
    assert _get_words(cli, ["-c", "a", "b"], "") == []


def test_argument_nargs():
    cli = Command(
        "cli",
        params=[
            Argument(["x"], type=Choice(["a", "b"]), nargs=2),
            Argument(["y"], type=Choice(["c", "d"]), nargs=-1),
            Option(["-z"]),
        ],
    )
    assert _get_words(cli, [], "") == ["a", "b"]
    assert _get_words(cli, ["a"], "") == ["a", "b"]
    assert _get_words(cli, ["a", "b"], "") == ["c", "d"]
    assert _get_words(cli, ["a", "b", "c"], "") == ["c", "d"]
    assert _get_words(cli, ["a", "b", "c", "d"], "") == ["c", "d"]
    assert _get_words(cli, ["a", "-z", "1"], "") == ["a", "b"]
    assert _get_words(cli, ["a", "-z", "1", "b"], "") == ["c", "d"]


def test_double_dash():
    cli = Command(
        "cli",
        add_help_option=False,
        params=[
            Option(["--opt"]),
            Argument(["name"], type=Choice(["name", "--", "-o", "--opt"])),
        ],
    )
    assert _get_words(cli, [], "-") == ["--opt"]
    assert _get_words(cli, ["value"], "-") == ["--opt"]
    assert _get_words(cli, [], "") == ["name", "--", "-o", "--opt"]
    assert _get_words(cli, ["--"], "") == ["name", "--", "-o", "--opt"]


def test_hidden():
    cli = Group(
        "cli",
        commands=[
            Command(
                "hidden",
                add_help_option=False,
                hidden=True,
                params=[
                    Option(["-a"]),
                    Option(["-b"], type=Choice(["a", "b"]), hidden=True),
                ],
            )
        ],
    )
    assert "hidden" not in _get_words(cli, [], "")
    assert "hidden" not in _get_words(cli, [], "hidden")
    assert _get_words(cli, ["hidden"], "-") == ["-a"]
    assert _get_words(cli, ["hidden", "-b"], "") == ["a", "b"]


def test_add_different_name():
    cli = Group("cli", commands={"renamed": Command("original")})
    words = _get_words(cli, [], "")
    assert "renamed" in words
    assert "original" not in words


def test_completion_item_data():
    c = CompletionItem("test", a=1)
    assert c.a == 1
    assert c.b is None


@pytest.fixture()
def _patch_for_completion(monkeypatch):
    monkeypatch.setattr(
        "click.shell_completion.BashComplete._check_version", lambda self: True
    )


@pytest.mark.parametrize("shell", ["bash", "zsh", "fish"])
@pytest.mark.usefixtures("_patch_for_completion")
def test_full_source(runner, shell):
    cli = Group("cli", commands=[Command("a"), Command("b")])
    result = runner.invoke(cli, env={"_CLI_COMPLETE": f"{shell}_source"})
    assert f"_CLI_COMPLETE={shell}_complete" in result.output


def test_full_source_powershell(runner):
    # The PowerShell source script sets the completion env var via
    # `$env:_CLI_COMPLETE = 'powershell_complete'`, so the substring
    # `_CLI_COMPLETE=powershell_complete` used by test_full_source above
    # is not present. Assert on the PowerShell-specific markers instead.
    cli = Group("cli", commands=[Command("a"), Command("b")])
    result = runner.invoke(cli, env={"_CLI_COMPLETE": "powershell_source"})
    assert "Register-ArgumentCompleter" in result.output
    assert "powershell_complete" in result.output


@pytest.mark.parametrize(
    ("shell", "env", "expect"),
    [
        ("bash", {"COMP_WORDS": "", "COMP_CWORD": "0"}, "plain,a\nplain,b\n"),
        ("bash", {"COMP_WORDS": "a b", "COMP_CWORD": "1"}, "plain,b\n"),
        ("zsh", {"COMP_WORDS": "", "COMP_CWORD": "0"}, "plain\na\n_\nplain\nb\nbee\n"),
        ("zsh", {"COMP_WORDS": "a b", "COMP_CWORD": "1"}, "plain\nb\nbee\n"),
        ("fish", {"COMP_WORDS": "", "COMP_CWORD": ""}, "plain,a\nplain,b\tbee\n"),
        ("fish", {"COMP_WORDS": "a b", "COMP_CWORD": "b"}, "plain,b\tbee\n"),
        ("fish", {"COMP_WORDS": 'a "b', "COMP_CWORD": '"b'}, "plain,b\tbee\n"),
        (
            "powershell",
            {"COMP_WORDS": "", "COMP_CWORD": "0"},
            "plain\na\n_\nplain\nb\nbee\n",
        ),
        ("powershell", {"COMP_WORDS": "a b", "COMP_CWORD": "1"}, "plain\nb\nbee\n"),
    ],
)
@pytest.mark.usefixtures("_patch_for_completion")
def test_full_complete(runner, shell, env, expect):
    cli = Group("cli", commands=[Command("a"), Command("b", help="bee")])
    env["_CLI_COMPLETE"] = f"{shell}_complete"
    result = runner.invoke(cli, env=env)
    assert result.output == expect


def test_source_uses_lf_line_endings(monkeypatch):
    stdout = io.BytesIO()
    stream = io.TextIOWrapper(stdout, encoding="utf-8", newline="\r\n")
    monkeypatch.setattr("click.utils._default_text_stdout", lambda: stream)

    cli = Group("cli", commands=[Command("a"), Command("b")])
    assert shell_complete(cli, {}, "cli", "_CLI_COMPLETE", "zsh_source") == 0

    stream.flush()
    output = stdout.getvalue()
    assert b"\r\n" not in output
    assert b"\n" in output


@pytest.mark.parametrize(
    ("env", "expect"),
    [
        (
            {"COMP_WORDS": "", "COMP_CWORD": "0"},
            textwrap.dedent(
                """\
                    plain
                    a
                    _
                    plain
                    b
                    bee
                    plain
                    c\\:d
                    cee:dee
                    plain
                    c:e
                    _
                """
            ),
        ),
        (
            {"COMP_WORDS": "a c", "COMP_CWORD": "1"},
            textwrap.dedent(
                """\
                    plain
                    c\\:d
                    cee:dee
                    plain
                    c:e
                    _
                """
            ),
        ),
        (
            {"COMP_WORDS": "a c:", "COMP_CWORD": "1"},
            textwrap.dedent(
                """\
                    plain
                    c\\:d
                    cee:dee
                    plain
                    c:e
                    _
                """
            ),
        ),
    ],
)
@pytest.mark.usefixtures("_patch_for_completion")
def test_zsh_full_complete_with_colons(
    runner, env: Mapping[str, str], expect: str
) -> None:
    cli = Group(
        "cli",
        commands=[
            Command("a"),
            Command("b", help="bee"),
            Command("c:d", help="cee:dee"),
            Command("c:e"),
        ],
    )
    result = runner.invoke(
        cli,
        env={
            **env,
            "_CLI_COMPLETE": "zsh_complete",
        },
    )
    assert result.output == expect


@pytest.mark.usefixtures("_patch_for_completion")
def test_context_settings(runner):
    def complete(ctx, param, incomplete):
        return ctx.obj["choices"]

    cli = Command("cli", params=[Argument("x", shell_complete=complete)])
    result = runner.invoke(
        cli,
        obj={"choices": ["a", "b"]},
        env={"COMP_WORDS": "", "COMP_CWORD": "0", "_CLI_COMPLETE": "bash_complete"},
    )
    assert result.output == "plain,a\nplain,b\n"


# case_sensitive=False normalizes values to lowercase, matching remains case insensitive
@pytest.mark.parametrize(("value", "expect"), [(False, ["au", "al"]), (True, ["al"])])
def test_choice_case_sensitive(value, expect):
    cli = Command(
        "cli",
        params=[Option(["-a"], type=Choice(["Au", "al", "Bc"], case_sensitive=value))],
    )
    completions = _get_words(cli, ["-a"], "a")
    assert completions == expect


@pytest.fixture()
def _restore_available_shells(tmpdir):
    prev_available_shells = click.shell_completion._available_shells.copy()
    click.shell_completion._available_shells.clear()
    yield
    click.shell_completion._available_shells.clear()
    click.shell_completion._available_shells.update(prev_available_shells)


@pytest.mark.usefixtures("_restore_available_shells")
def test_add_completion_class():
    # At first, "mysh" is not in available shells
    assert "mysh" not in click.shell_completion._available_shells

    class MyshComplete(ShellComplete):
        name = "mysh"
        source_template = "dummy source"

    # "mysh" still not in available shells because it is not registered
    assert "mysh" not in click.shell_completion._available_shells

    # Adding a completion class should return that class
    assert add_completion_class(MyshComplete) is MyshComplete

    # Now, "mysh" is finally in available shells
    assert "mysh" in click.shell_completion._available_shells
    assert click.shell_completion._available_shells["mysh"] is MyshComplete


@pytest.mark.usefixtures("_restore_available_shells")
def test_add_completion_class_with_name():
    # At first, "mysh" is not in available shells
    assert "mysh" not in click.shell_completion._available_shells
    assert "not_mysh" not in click.shell_completion._available_shells

    class MyshComplete(ShellComplete):
        name = "not_mysh"
        source_template = "dummy source"

    # "mysh" and "not_mysh" are still not in available shells because
    # it is not registered yet
    assert "mysh" not in click.shell_completion._available_shells
    assert "not_mysh" not in click.shell_completion._available_shells

    # Adding a completion class should return that class.
    # Because we are using the "name" parameter, the name isn't taken
    # from the class.
    assert add_completion_class(MyshComplete, name="mysh") is MyshComplete

    # Now, "mysh" is finally in available shells
    assert "mysh" in click.shell_completion._available_shells
    assert "not_mysh" not in click.shell_completion._available_shells
    assert click.shell_completion._available_shells["mysh"] is MyshComplete


@pytest.mark.usefixtures("_restore_available_shells")
def test_add_completion_class_decorator():
    # At first, "mysh" is not in available shells
    assert "mysh" not in click.shell_completion._available_shells

    @add_completion_class
    class MyshComplete(ShellComplete):
        name = "mysh"
        source_template = "dummy source"

    # Using `add_completion_class` as a decorator adds the new shell immediately
    assert "mysh" in click.shell_completion._available_shells
    assert click.shell_completion._available_shells["mysh"] is MyshComplete


# Don't make the ResourceWarning give an error
@pytest.mark.filterwarnings("default::ResourceWarning")
def test_files_closed(tmp_path) -> None:
    config_file = str(tmp_path / "foo.txt")
    with open(config_file, "w") as f:
        f.write("bar")

    @click.group()
    @click.option(
        "--config-file",
        default=config_file,
        type=click.File(mode="r"),
    )
    @click.pass_context
    def cli(ctx, config_file):
        pass

    with warnings.catch_warnings(record=True) as current_warnings:
        assert not current_warnings, "There should be no warnings to start"
        _get_completions(cli, args=[], incomplete="")
        assert not current_warnings, "There should be no warnings after either"


def test_fish_format_completion_escapes_help():
    fc = FishComplete(Command("x"), {}, "x", "_X_COMPLETE")
    item = CompletionItem("--at", help="first\nsecond\tthird")
    # The newline is escaped to the literal characters backslash-n and the tab
    # becomes a space, so each completion stays on one line for fish.
    assert fc.format_completion(item) == "plain,--at\tfirst\\nsecond third"


def test_powershell_format_completion_escapes_help():
    pc = PowerShellComplete(Command("x"), {}, "x", "_X_COMPLETE")
    # Newlines (LF and CRLF) collapse to spaces so the help text stays
    # on a single line and doesn't break the 3-lines-per-item framing
    # consumed by the PowerShell completion script.
    item = CompletionItem("--at", help="first\nsecond\r\nthird")
    assert pc.format_completion(item) == "plain\n--at\nfirst second  third"
    # Items without help text use the "_" sentinel, matching the format
    # produced by ZshComplete.
    item = CompletionItem("--at")
    assert pc.format_completion(item) == "plain\n--at\n_"

'use strict'

/**
 * Module dependencies.
 */

var express = require('../..');
var logger = require('morgan');
var session = require('express-session');

// pass the express to the connect redis module
// allowing it to inherit from session.Store
var RedisStore = require('connect-redis')(session);

var app = express();

app.use(logger('dev'));

// Populates req.session
app.use(session({
  resave: false, // don't save session if unmodified
  saveUninitialized: false, // don't create session until something stored
  secret: 'keyboard cat',
  store: new RedisStore
}));

app.get('/', function(req, res){
  var body = '';
  if (req.session.views) {
    ++req.session.views;
  } else {
    req.session.views = 1;
    body += '<p>First time visiting? view this page in several browsers :)</p>';
  }
  res.send(body + '<p>viewed <strong>' + req.session.views + '</strong> times.</p>');
});

app.listen(3000);
console.log('Express app started on port 3000');

var app = require('../../examples/error')
  , request = require('supertest');

describe('error', function(){
  describe('GET /', function(){
    it('should respond with 500', function(done){
      request(app)
        .get('/')
        .expect(500,done)
    })
  })

  describe('GET /next', function(){
    it('should respond with 500', function(done){
      request(app)
        .get('/next')
        .expect(500,done)
    })
  })

  describe('GET /missing', function(){
    it('should respond with 404', function(done){
      request(app)
        .get('/missing')
        .expect(404,done)
    })
  })
})

'use strict'

var express = require('..');
var path = require('node:path')
var request = require('supertest');
var tmpl = require('./support/tmpl');

describe('res', function(){
  describe('.render(name)', function(){
    it('should support absolute paths', function(done){
      var app = createApp();

      app.locals.user = { name: 'tobi' };

      app.use(function(req, res){
        res.render(path.join(__dirname, 'fixtures', 'user.tmpl'))
      });

      request(app)
      .get('/')
      .expect('<p>tobi</p>', done);
    })

    it('should support absolute paths with "view engine"', function(done){
      var app = createApp();

      app.locals.user = { name: 'tobi' };
      app.set('view engine', 'tmpl');

      app.use(function(req, res){
        res.render(path.join(__dirname, 'fixtures', 'user'))
      });

      request(app)
      .get('/')
      .expect('<p>tobi</p>', done);
    })

    it('should error without "view engine" set and file extension to a non-engine module', function (done) {
      var app = createApp()

      app.locals.user = { name: 'tobi' }

      app.use(function (req, res) {
        res.render(path.join(__dirname, 'fixtures', 'broken.send'))
      })

      request(app)
      .get('/')
      .expect(500, /does not provide a view engine/, done)
    })

    it('should error without "view engine" set and no file extension', function (done) {
      var app = createApp();

      app.locals.user = { name: 'tobi' };

      app.use(function(req, res){
        res.render(path.join(__dirname, 'fixtures', 'user'))
      });

      request(app)
      .get('/')
      .expect(500, /No default engine was specified/, done);
    })

    it('should expose app.locals', function(done){
      var app = createApp();

      app.set('views', path.join(__dirname, 'fixtures'))
      app.locals.user = { name: 'tobi' };

      app.use(function(req, res){
        res.render('user.tmpl');
      });

      request(app)
      .get('/')
      .expect('<p>tobi</p>', done);
    })

    it('should expose app.locals with `name` property', function(done){
      var app = createApp();

      app.set('views', path.join(__dirname, 'fixtures'))
      app.locals.name = 'tobi';

      app.use(function(req, res){
        res.render('name.tmpl');
      });

      request(app)
      .get('/')
      .expect('<p>tobi</p>', done);
    })

    it('should support index.<engine>', function(done){
      var app = createApp();

      app.set('views', path.join(__dirname, 'fixtures'))
      app.set('view engine', 'tmpl');

      app.use(function(req, res){
        res.render('blog/post');
      });

      request(app)
      .get('/')
      .expect('<h1>blog post</h1>', done);
    })

    describe('when an error occurs', function(){
      it('should next(err)', function(done){
        var app = createApp();

        app.set('views', path.join(__dirname, 'fixtures'))

        app.use(function(req, res){
          res.render('user.tmpl');
        });

        app.use(function(err, req, res, next){
          res.status(500).send('got error: ' + err.name)
        });

        request(app)
        .get('/')
        .expect(500, 'got error: RenderError', done)
      })
    })

    describe('when "view engine" is given', function(){
      it('should render the template', function(done){
        var app = createApp();

        app.set('view engine', 'tmpl');
        app.set('views', path.join(__dirname, 'fixtures'))

        app.use(function(req, res){
          res.render('email');
        });

        request(app)
        .get('/')
        .expect('<p>This is an email</p>', done);
      })
    })

    describe('when "views" is given', function(){
      it('should lookup the file in the path', function(done){
        var app = createApp();

        app.set('views', path.join(__dirname, 'fixtures', 'default_layout'))

        app.use(function(req, res){
          res.render('user.tmpl', { user: { name: 'tobi' } });
        });

        request(app)
        .get('/')
        .expect('<p>tobi</p>', done);
      })

      describe('when array of paths', function(){
        it('should lookup the file in the path', function(done){
          var app = createApp();
          var views = [
            path.join(__dirname, 'fixtures', 'local_layout'),
            path.join(__dirname, 'fixtures', 'default_layout')
          ]

          app.set('views', views);

          app.use(function(req, res){
            res.render('user.tmpl', { user: { name: 'tobi' } });
          });

          request(app)
          .get('/')
          .expect('<span>tobi</span>', done);
        })

        it('should lookup in later paths until found', function(done){
          var app = createApp();
          var views = [
            path.join(__dirname, 'fixtures', 'local_layout'),
            path.join(__dirname, 'fixtures', 'default_layout')
          ]

          app.set('views', views);

          app.use(function(req, res){
            res.render('name.tmpl', { name: 'tobi' });
          });

          request(app)
          .get('/')
          .expect('<p>tobi</p>', done);
        })
      })
    })
  })

  describe('.render(name, option)', function(){
    it('should render the template', function(done){
      var app = createApp();

      app.set('views', path.join(__dirname, 'fixtures'))

      var user = { name: 'tobi' };

      app.use(function(req, res){
        res.render('user.tmpl', { user: user });
      });

      request(app)
      .get('/')
      .expect('<p>tobi</p>', done);
    })

    it('should expose app.locals', function(done){
      var app = createApp();

      app.set('views', path.join(__dirname, 'fixtures'))
      app.locals.user = { name: 'tobi' };

      app.use(function(req, res){
        res.render('user.tmpl');
      });

      request(app)
      .get('/')
      .expect('<p>tobi</p>', done);
    })

    it('should expose res.locals', function(done){
      var app = createApp();

      app.set('views', path.join(__dirname, 'fixtures'))

      app.use(function(req, res){
        res.locals.user = { name: 'tobi' };
        res.render('user.tmpl');
      });

      request(app)
      .get('/')
      .expect('<p>tobi</p>', done);
    })

    it('should give precedence to res.locals over app.locals', function(done){
      var app = createApp();

      app.set('views', path.join(__dirname, 'fixtures'))
      app.locals.user = { name: 'tobi' };

      app.use(function(req, res){
        res.locals.user = { name: 'jane' };
        res.render('user.tmpl', {});
      });

      request(app)
      .get('/')
      .expect('<p>jane</p>', done);
    })

    it('should give precedence to res.render() locals over res.locals', function(done){
      var app = createApp();

      app.set('views', path.join(__dirname, 'fixtures'))
      var jane = { name: 'jane' };

      app.use(function(req, res){
        res.locals.user = { name: 'tobi' };
        res.render('user.tmpl', { user: jane });
      });

      request(app)
      .get('/')
      .expect('<p>jane</p>', done);
    })

    it('should give precedence to res.render() locals over app.locals', function(done){
      var app = createApp();

      app.set('views', path.join(__dirname, 'fixtures'))
      app.locals.user = { name: 'tobi' };
      var jane = { name: 'jane' };

      app.use(function(req, res){
        res.render('user.tmpl', { user: jane });
      });

      request(app)
      .get('/')
      .expect('<p>jane</p>', done);
    })
  })

  describe('.render(name, options, fn)', function(){
    it('should pass the resulting string', function(done){
      var app = createApp();

      app.set('views', path.join(__dirname, 'fixtures'))

      app.use(function(req, res){
        var tobi = { name: 'tobi' };
        res.render('user.tmpl', { user: tobi }, function (err, html) {
          html = html.replace('tobi', 'loki');
          res.end(html);
        });
      });

      request(app)
      .get('/')
      .expect('<p>loki</p>', done);
    })
  })

  describe('.render(name, fn)', function(){
    it('should pass the resulting string', function(done){
      var app = createApp();

      app.set('views', path.join(__dirname, 'fixtures'))

      app.use(function(req, res){
        res.locals.user = { name: 'tobi' };
        res.render('user.tmpl', function (err, html) {
          html = html.replace('tobi', 'loki');
          res.end(html);
        });
      });

      request(app)
      .get('/')
      .expect('<p>loki</p>', done);
    })

    describe('when an error occurs', function(){
      it('should pass it to the callback', function(done){
        var app = createApp();

        app.set('views', path.join(__dirname, 'fixtures'))

        app.use(function(req, res){
          res.render('user.tmpl', function (err) {
            if (err) {
              res.status(500).send('got error: ' + err.name)
            }
          });
        });

        request(app)
        .get('/')
        .expect(500, 'got error: RenderError', done)
      })
    })
  })
})

function createApp() {
  var app = express();

  app.engine('.tmpl', tmpl);

  return app;
}

import pytest

import click


def test_command_no_parens(runner):
    @click.command
    def cli():
        click.echo("hello")

    result = runner.invoke(cli)
    assert result.exception is None
    assert result.output == "hello\n"


def test_custom_command_no_parens(runner):
    class CustomCommand(click.Command):
        pass

    class CustomGroup(click.Group):
        command_class = CustomCommand

    @click.group(cls=CustomGroup)
    def grp():
        pass

    @grp.command
    def cli():
        click.echo("hello custom command class")

    result = runner.invoke(cli)
    assert result.exception is None
    assert result.output == "hello custom command class\n"


def test_group_no_parens(runner):
    @click.group
    def grp():
        click.echo("grp1")

    @grp.command
    def cmd1():
        click.echo("cmd1")

    @grp.group
    def grp2():
        click.echo("grp2")

    @grp2.command
    def cmd2():
        click.echo("cmd2")

    result = runner.invoke(grp, ["cmd1"])
    assert result.exception is None
    assert result.output == "grp1\ncmd1\n"

    result = runner.invoke(grp, ["grp2", "cmd2"])
    assert result.exception is None
    assert result.output == "grp1\ngrp2\ncmd2\n"


def test_params_argument(runner):
    opt = click.Argument(["a"])

    @click.command(params=[opt])
    @click.argument("b")
    def cli(a, b):
        click.echo(f"{a} {b}")

    assert cli.params[0].name == "a"
    assert cli.params[1].name == "b"
    result = runner.invoke(cli, ["1", "2"])
    assert result.output == "1 2\n"


@pytest.mark.parametrize(
    "name",
    [
        "init_data",
        "init_data_command",
        "init_data_cmd",
        "init_data_group",
        "init_data_grp",
    ],
)
def test_generate_name(name: str) -> None:
    def f():
        pass

    f.__name__ = name
    f = click.command(f)
    assert f.name == "init-data"

from jinja2 import Environment

env = Environment(
    line_statement_prefix="%", variable_start_string="${", variable_end_string="}"
)
tmpl = env.from_string(
    """\
% macro foo()
    ${caller(42)}
% endmacro
<ul>
% for item in seq
    <li>${item}</li>
% endfor
</ul>
% call(var) foo()
    [${var}]
% endcall
% filter escape
    <hello world>
    % for item in [1, 2, 3]
      -  ${item}
    % endfor
% endfilter
"""
)
print(tmpl.render(seq=range(10)))

'use strict'

/**
 * Module dependencies.
 */

var db = require('../../db');

exports.engine = 'hbs';

exports.before = function(req, res, next){
  var id = req.params.user_id;
  if (!id) return next();
  // pretend to query a database...
  process.nextTick(function(){
    req.user = db.users[id];
    // cant find that user
    if (!req.user) return next('route');
    // found it, move on to the routes
    next();
  });
};

exports.list = function(req, res, next){
  res.render('list', { users: db.users });
};

exports.edit = function(req, res, next){
  res.render('edit', { user: req.user });
};

exports.show = function(req, res, next){
  res.render('show', { user: req.user });
};

exports.update = function(req, res, next){
  var body = req.body;
  req.user.name = body.user.name;
  res.message('Information updated!');
  res.redirect('/user/' + req.user.id);
};

'use strict'

/**
 * Module dependencies.
 */

var db = require('../../db');

exports.engine = 'ejs';

exports.before = function(req, res, next){
  var pet = db.pets[req.params.pet_id];
  if (!pet) return next('route');
  req.pet = pet;
  next();
};

exports.show = function(req, res, next){
  res.render('show', { pet: req.pet });
};

exports.edit = function(req, res, next){
  res.render('edit', { pet: req.pet });
};

exports.update = function(req, res, next){
  var body = req.body;
  req.pet.name = body.pet.name;
  res.message('Information updated!');
  res.redirect('/pet/' + req.pet.id);
};

name: Windows Builds (Basic)

on: [push, pull_request]

env:
  CTEST_OUTPUT_ON_FAILURE: 1
  CTEST_NO_TESTS_ACTION: error

jobs:
  build:
    name: ${{matrix.os}}, ${{matrix.std}}, ${{matrix.build_type}}, ${{matrix.platform}}
    runs-on: ${{matrix.os}}
    strategy:
      fail-fast: false
      matrix:
        os: [windows-2022, windows-2025]
        platform: [Win32, x64]
        build_type: [Debug, Release]
        std: [14, 17]
    steps:
      - uses: actions/checkout@v6

      - name: Configure build
        run: |
          cmake --preset all-tests `
                -A ${{matrix.platform}} `
                -DCMAKE_CXX_STANDARD=${{matrix.std}} `

      - name: Build tests
        run: cmake --build build --config ${{matrix.build_type}} --parallel %NUMBER_OF_PROCESSORS%
        shell: cmd

      - name: Run tests
        run: ctest --test-dir build -C ${{matrix.build_type}} -j %NUMBER_OF_PROCESSORS%
        shell: cmd

import click


def test_command_context_class():
    """A command with a custom ``context_class`` should produce a
    context using that type.
    """

    class CustomContext(click.Context):
        pass

    class CustomCommand(click.Command):
        context_class = CustomContext

    command = CustomCommand("test")
    context = command.make_context("test", [])
    assert isinstance(context, CustomContext)


def test_context_invoke_type(runner):
    """A command invoked from a custom context should have a new
    context with the same type.
    """

    class CustomContext(click.Context):
        pass

    class CustomCommand(click.Command):
        context_class = CustomContext

    @click.command()
    @click.argument("first_id", type=int)
    @click.pass_context
    def second(ctx, first_id):
        assert isinstance(ctx, CustomContext)
        assert id(ctx) != first_id

    @click.command(cls=CustomCommand)
    @click.pass_context
    def first(ctx):
        assert isinstance(ctx, CustomContext)
        ctx.invoke(second, first_id=id(ctx))

    assert not runner.invoke(first).exception


def test_context_formatter_class():
    """A context with a custom ``formatter_class`` should format help
    using that type.
    """

    class CustomFormatter(click.HelpFormatter):
        def write_heading(self, heading):
            heading = click.style(heading, fg="yellow")
            return super().write_heading(heading)

    class CustomContext(click.Context):
        formatter_class = CustomFormatter

    context = CustomContext(
        click.Command("test", params=[click.Option(["--value"])]), color=True
    )
    assert "\x1b[33mOptions\x1b[0m:" in context.get_help()


def test_group_command_class(runner):
    """A group with a custom ``command_class`` should create subcommands
    of that type by default.
    """

    class CustomCommand(click.Command):
        pass

    class CustomGroup(click.Group):
        command_class = CustomCommand

    group = CustomGroup()
    subcommand = group.command()(lambda: None)
    assert type(subcommand) is CustomCommand
    subcommand = group.command(cls=click.Command)(lambda: None)
    assert type(subcommand) is click.Command


def test_group_group_class(runner):
    """A group with a custom ``group_class`` should create subgroups
    of that type by default.
    """

    class CustomSubGroup(click.Group):
        pass

    class CustomGroup(click.Group):
        group_class = CustomSubGroup

    group = CustomGroup()
    subgroup = group.group()(lambda: None)
    assert type(subgroup) is CustomSubGroup
    subgroup = group.command(cls=click.Group)(lambda: None)
    assert type(subgroup) is click.Group


def test_group_group_class_self(runner):
    """A group with ``group_class = type`` should create subgroups of
    the same type as itself.
    """

    class CustomGroup(click.Group):
        group_class = type

    group = CustomGroup()
    subgroup = group.group()(lambda: None)
    assert type(subgroup) is CustomGroup

name: CI
on:
  - push
  - pull_request
permissions:
  contents: read
jobs:
  test:
    name: Node.js ${{ matrix.node-version }} on ${{ matrix.os }}
    runs-on: ${{ matrix.os }}
    strategy:
      fail-fast: false
      matrix:
        node-version:
          - 24
          - 22
        os:
          - ubuntu-latest
    steps:
      - uses: actions/checkout@v6
      - uses: actions/setup-node@v6
        with:
          node-version: ${{ matrix.node-version }}
      - run: npm install
      - run: npm run test

<a id="top"></a>
# Other macros

This page serves as a reference for macros that are not documented
elsewhere. For now, these macros are separated into 2 rough categories,
"assertion related macros" and "test case related macros".

## Assertion related macros

* `CHECKED_IF` and `CHECKED_ELSE`

`CHECKED_IF( expr )` is an `if` replacement, that also applies Catch2's
stringification machinery to the _expr_ and records the result. As with
`if`, the block after a `CHECKED_IF` is entered only if the expression
evaluates to `true`. `CHECKED_ELSE( expr )` work similarly, but the block
is entered only if the _expr_ evaluated to `false`.

> `CHECKED_X` macros were changed to not count as failure in Catch2 3.0.1.

Example:
```cpp
int a = ...;
int b = ...;
CHECKED_IF( a == b ) {
    // This block is entered when a == b
} CHECKED_ELSE ( a == b ) {
    // This block is entered when a != b
}
```

* `CHECK_NOFAIL`

`CHECK_NOFAIL( expr )` is a variant of `CHECK` that does not fail the test
case if _expr_ evaluates to `false`. This can be useful for checking some
assumption, that might be violated without the test necessarily failing.

Example output:
```
main.cpp:6:
FAILED - but was ok:
  CHECK_NOFAIL( 1 == 2 )

main.cpp:7:
PASSED:
  CHECK( 2 == 2 )
```

* `SUCCEED`

`SUCCEED( msg )` is mostly equivalent with `INFO( msg ); REQUIRE( true );`.
In other words, `SUCCEED` is for cases where just reaching a certain line
means that the test has been a success.

Example usage:
```cpp
TEST_CASE( "SUCCEED showcase" ) {
    int I = 1;
    SUCCEED( "I is " << I );
}
```

* `STATIC_REQUIRE` and `STATIC_CHECK`

> `STATIC_REQUIRE` was [introduced](https://github.com/catchorg/Catch2/issues/1362) in Catch2 2.4.2.

`STATIC_REQUIRE( expr )` is a macro that can be used the same way as a
`static_assert`, but also registers the success with Catch2, so it is
reported as a success at runtime. The whole check can also be deferred
to the runtime, by defining `CATCH_CONFIG_RUNTIME_STATIC_REQUIRE` before
including the Catch2 header.

Example:
```cpp
TEST_CASE("STATIC_REQUIRE showcase", "[traits]") {
    STATIC_REQUIRE( std::is_void<void>::value );
    STATIC_REQUIRE_FALSE( std::is_void<int>::value );
}
```

> `STATIC_CHECK` was [introduced](https://github.com/catchorg/Catch2/pull/2318) in Catch2 3.0.1.

`STATIC_CHECK( expr )` is equivalent to `STATIC_REQUIRE( expr )`, with the
difference that when `CATCH_CONFIG_RUNTIME_STATIC_REQUIRE` is defined, it
becomes equivalent to `CHECK` instead of `REQUIRE`.

Example:
```cpp
TEST_CASE("STATIC_CHECK showcase", "[traits]") {
    STATIC_CHECK( std::is_void<void>::value );
    STATIC_CHECK_FALSE( std::is_void<int>::value );
}
```

* `STATIC_REQUIRE_THAT` and `STATIC_CHECK_THAT`

> `STATIC_REQUIRE_THAT` and `STATIC_CHECK_THAT` was introduced in Catch2 3.15.0

`STATIC_{REQUIRE,CHECK}_THAT` are analogous to `STATIC_{REQUIRE,CHECK}`,
but for matchers. They are always defined, even if the current compiler
does not support `constexpr` matchers, but in that case the compilation
will always fail.

Just like `STATIC_{REQUIRE,CHECK}`, `STATIC_{REQUIRE,CHECK}_THAT` can be
delayed into runtime through the `CATCH_CONFIG_RUNTIME_STATIC_REQUIRE`
configuration option.

Example:
```cpp
TEST_CASE("Constexpr support for matchers", "[constexpr][matchers]") {
    STATIC_REQUIRE_THAT( 1, MatchAll() );
    STATIC_REQUIRE_THAT( 1, MatchAll() && MatchAll() );
    STATIC_REQUIRE_THAT( 1, MatchAll() || MatchAll() );
    STATIC_REQUIRE_THAT( 1, !!MatchAll() );
}
```


## Test case related macros

* `REGISTER_TEST_CASE`

`REGISTER_TEST_CASE( function, description )` let's you register
a `function` as a test case. The function has to have `void()` signature,
the description can contain both name and tags.

Example:
```cpp
REGISTER_TEST_CASE( someFunction, "ManuallyRegistered", "[tags]" );
```

_Note that the registration still has to happen before Catch2's session
is initiated. This means that it either needs to be done in a global
constructor, or before Catch2's session is created in user's own main._


* `DYNAMIC_SECTION`

> Introduced in Catch2 2.3.0.

`DYNAMIC_SECTION` is a `SECTION` where the user can use `operator<<` to
create the final name for that section. This can be useful with e.g.
generators, or when creating a `SECTION` dynamically, within a loop.

Example:
```cpp
TEST_CASE( "looped SECTION tests" ) {
    int a = 1;

    for( int b = 0; b < 10; ++b ) {
        DYNAMIC_SECTION( "b is currently: " << b ) {
            CHECK( b > a );
        }
    }
}
```

import http2, {type ServerHttp2Stream} from 'node:http2';
import type net from 'node:net';
import pify from 'pify';
import pem from 'pem';
import type {CreateCertificate} from '../types/pem.js';

const createCertificate = pify(pem.createCertificate as CreateCertificate);

export type Http2TestServer = {
	server: http2.Http2SecureServer;
	sessions: Set<NonNullable<ServerHttp2Stream['session']>>;
	url: string;
	close: () => Promise<void>;
};

export default async function createHttp2TestServer(onStream: (stream: ServerHttp2Stream, headers: http2.IncomingHttpHeaders) => void): Promise<Http2TestServer> {
	const certificate = await createCertificate({days: 1, selfSigned: true});
	const server = http2.createSecureServer({
		key: certificate.serviceKey,
		cert: certificate.certificate,
	});
	const sessions = new Set<NonNullable<ServerHttp2Stream['session']>>();

	server.on('stream', onStream);
	server.on('session', session => {
		sessions.add(session);
		session.once('close', () => {
			sessions.delete(session);
		});
	});

	await new Promise<void>(resolve => {
		server.listen(0, 'localhost', resolve);
	});

	const {port} = server.address() as net.AddressInfo;

	return {
		server,
		sessions,
		url: `https://localhost:${port}`,
		async close() {
			for (const session of sessions) {
				session.destroy();
			}

			await new Promise<void>((resolve, reject) => {
				server.close(error => {
					if (error) {
						reject(error);
						return;
					}

					resolve();
				});
			});
		},
	};
}

from __future__ import annotations

import codecs
import collections.abc as cabc
import io
import os
import re
import sys
import typing as t
from types import TracebackType
from weakref import WeakKeyDictionary

CYGWIN = sys.platform.startswith("cygwin")
WIN = sys.platform.startswith("win")
# One CSI escape sequence per the ECMA-48 grammar: parameter bytes (0x30-0x3F),
# intermediate bytes (0x20-0x2F), then a final byte (0x40-0x7E). Broader than the
# SGR codes Click emits, so foreign sequences (colon-delimited true-color, mouse
# reporting) are stripped too.
_ansi_re = re.compile(r"\033\[[0-?]*[ -/]*[@-~]")


def _make_text_stream(
    stream: t.BinaryIO,
    encoding: str | None,
    errors: str | None,
    force_readable: bool = False,
    force_writable: bool = False,
) -> t.TextIO:
    if encoding is None:
        encoding = get_best_encoding(stream)
    if errors is None:
        errors = "replace"
    return _NonClosingTextIOWrapper(
        stream,
        encoding,
        errors,
        line_buffering=True,
        force_readable=force_readable,
        force_writable=force_writable,
    )


def is_ascii_encoding(encoding: str) -> bool:
    """Checks if a given encoding is ascii."""
    try:
        return codecs.lookup(encoding).name == "ascii"
    except LookupError:
        return False


def get_best_encoding(stream: t.IO[t.Any]) -> str:
    """Returns the default stream encoding if not found."""
    rv = getattr(stream, "encoding", None) or sys.getdefaultencoding()
    if is_ascii_encoding(rv):
        return "utf-8"
    return rv


class _NonClosingTextIOWrapper(io.TextIOWrapper):
    def __init__(
        self,
        stream: t.BinaryIO,
        encoding: str | None,
        errors: str | None,
        force_readable: bool = False,
        force_writable: bool = False,
        **extra: t.Any,
    ) -> None:
        self._stream = stream = t.cast(
            t.BinaryIO, _FixupStream(stream, force_readable, force_writable)
        )
        super().__init__(stream, encoding, errors, **extra)

    def __del__(self) -> None:
        try:
            self.detach()
        except Exception:
            pass

    def isatty(self) -> bool:
        # https://bitbucket.org/pypy/pypy/issue/1803
        return self._stream.isatty()


class _FixupStream:
    """The new io interface needs more from streams than streams
    traditionally implement.  As such, this fix-up code is necessary in
    some circumstances.

    The forcing of readable and writable flags are there because some tools
    put badly patched objects on sys (one such offender are certain version
    of jupyter notebook).
    """

    def __init__(
        self,
        stream: t.BinaryIO,
        force_readable: bool = False,
        force_writable: bool = False,
    ):
        self._stream = stream
        self._force_readable = force_readable
        self._force_writable = force_writable

    def __getattr__(self, name: str) -> t.Any:
        return getattr(self._stream, name)

    def read1(self, size: int) -> bytes:
        f = getattr(self._stream, "read1", None)

        if f is not None:
            return t.cast(bytes, f(size))

        return self._stream.read(size)

    def readable(self) -> bool:
        if self._force_readable:
            return True
        x = getattr(self._stream, "readable", None)
        if x is not None:
            return t.cast(bool, x())
        try:
            self._stream.read(0)
        except Exception:
            return False
        return True

    def writable(self) -> bool:
        if self._force_writable:
            return True
        x = getattr(self._stream, "writable", None)
        if x is not None:
            return t.cast(bool, x())
        try:
            self._stream.write(b"")
        except Exception:
            try:
                self._stream.write(b"")
            except Exception:
                return False
        return True

    def seekable(self) -> bool:
        x = getattr(self._stream, "seekable", None)
        if x is not None:
            return t.cast(bool, x())
        try:
            self._stream.seek(self._stream.tell())
        except Exception:
            return False
        return True


def _is_binary_reader(stream: t.IO[t.Any], default: bool = False) -> bool:
    try:
        return isinstance(stream.read(0), bytes)
    except Exception:
        return default
        # This happens in some cases where the stream was already
        # closed.  In this case, we assume the default.


def _is_binary_writer(stream: t.IO[t.Any], default: bool = False) -> bool:
    try:
        stream.write(b"")
    except Exception:
        try:
            stream.write("")
            return False
        except Exception:
            pass
        return default
    return True


def _find_binary_reader(stream: t.IO[t.Any]) -> t.BinaryIO | None:
    # We need to figure out if the given stream is already binary.
    # This can happen because the official docs recommend detaching
    # the streams to get binary streams.  Some code might do this, so
    # we need to deal with this case explicitly.
    if _is_binary_reader(stream, False):
        return t.cast(t.BinaryIO, stream)

    buf = getattr(stream, "buffer", None)

    # Same situation here; this time we assume that the buffer is
    # actually binary in case it's closed.
    if buf is not None and _is_binary_reader(buf, True):
        return t.cast(t.BinaryIO, buf)

    return None


def _find_binary_writer(stream: t.IO[t.Any]) -> t.BinaryIO | None:
    # We need to figure out if the given stream is already binary.
    # This can happen because the official docs recommend detaching
    # the streams to get binary streams.  Some code might do this, so
    # we need to deal with this case explicitly.
    if _is_binary_writer(stream, False):
        return t.cast(t.BinaryIO, stream)

    buf = getattr(stream, "buffer", None)

    # Same situation here; this time we assume that the buffer is
    # actually binary in case it's closed.
    if buf is not None and _is_binary_writer(buf, True):
        return t.cast(t.BinaryIO, buf)

    return None


def _stream_is_misconfigured(stream: t.TextIO) -> bool:
    """A stream is misconfigured if its encoding is ASCII."""
    # If the stream does not have an encoding set, we assume it's set
    # to ASCII.  This appears to happen in certain unittest
    # environments.  It's not quite clear what the correct behavior is
    # but this at least will force Click to recover somehow.
    return is_ascii_encoding(getattr(stream, "encoding", None) or "ascii")


def _is_compat_stream_attr(stream: t.TextIO, attr: str, value: str | None) -> bool:
    """A stream attribute is compatible if it is equal to the
    desired value or the desired value is unset and the attribute
    has a value.
    """
    stream_value = getattr(stream, attr, None)
    return stream_value == value or (value is None and stream_value is not None)


def _is_compatible_text_stream(
    stream: t.TextIO, encoding: str | None, errors: str | None
) -> bool:
    """Check if a stream's encoding and errors attributes are
    compatible with the desired values.
    """
    return _is_compat_stream_attr(
        stream, "encoding", encoding
    ) and _is_compat_stream_attr(stream, "errors", errors)


def _force_correct_text_stream(
    text_stream: t.IO[t.Any],
    encoding: str | None,
    errors: str | None,
    is_binary: t.Callable[[t.IO[t.Any], bool], bool],
    find_binary: t.Callable[[t.IO[t.Any]], t.BinaryIO | None],
    force_readable: bool = False,
    force_writable: bool = False,
) -> t.TextIO:
    if is_binary(text_stream, False):
        binary_reader = t.cast(t.BinaryIO, text_stream)
    else:
        text_stream = t.cast(t.TextIO, text_stream)
        # If the stream looks compatible, and won't default to a
        # misconfigured ascii encoding, return it as-is.
        if _is_compatible_text_stream(text_stream, encoding, errors) and not (
            encoding is None and _stream_is_misconfigured(text_stream)
        ):
            return text_stream

        # Otherwise, get the underlying binary reader.
        possible_binary_reader = find_binary(text_stream)

        # If that's not possible, silently use the original reader
        # and get mojibake instead of exceptions.
        if possible_binary_reader is None:
            return text_stream

        binary_reader = possible_binary_reader

    # Default errors to replace instead of strict in order to get
    # something that works.
    if errors is None:
        errors = "replace"

    # Wrap the binary stream in a text stream with the correct
    # encoding parameters.
    return _make_text_stream(
        binary_reader,
        encoding,
        errors,
        force_readable=force_readable,
        force_writable=force_writable,
    )


def _force_correct_text_reader(
    text_reader: t.IO[t.Any],
    encoding: str | None,
    errors: str | None,
    force_readable: bool = False,
) -> t.TextIO:
    return _force_correct_text_stream(
        text_reader,
        encoding,
        errors,
        _is_binary_reader,
        _find_binary_reader,
        force_readable=force_readable,
    )


def _force_correct_text_writer(
    text_writer: t.IO[t.Any],
    encoding: str | None,
    errors: str | None,
    force_writable: bool = False,
) -> t.TextIO:
    return _force_correct_text_stream(
        text_writer,
        encoding,
        errors,
        _is_binary_writer,
        _find_binary_writer,
        force_writable=force_writable,
    )


def get_binary_stdin() -> t.BinaryIO:
    reader = _find_binary_reader(sys.stdin)
    if reader is None:
        raise RuntimeError("Was not able to determine binary stream for sys.stdin.")
    return reader


def get_binary_stdout() -> t.BinaryIO:
    writer = _find_binary_writer(sys.stdout)
    if writer is None:
        raise RuntimeError("Was not able to determine binary stream for sys.stdout.")
    return writer


def get_binary_stderr() -> t.BinaryIO:
    writer = _find_binary_writer(sys.stderr)
    if writer is None:
        raise RuntimeError("Was not able to determine binary stream for sys.stderr.")
    return writer


def get_text_stdin(encoding: str | None = None, errors: str | None = None) -> t.TextIO:
    rv = _get_windows_console_stream(sys.stdin, encoding, errors)
    if rv is not None:
        return rv
    return _force_correct_text_reader(sys.stdin, encoding, errors, force_readable=True)


def get_text_stdout(encoding: str | None = None, errors: str | None = None) -> t.TextIO:
    rv = _get_windows_console_stream(sys.stdout, encoding, errors)
    if rv is not None:
        return rv
    return _force_correct_text_writer(sys.stdout, encoding, errors, force_writable=True)


def get_text_stderr(encoding: str | None = None, errors: str | None = None) -> t.TextIO:
    rv = _get_windows_console_stream(sys.stderr, encoding, errors)
    if rv is not None:
        return rv
    return _force_correct_text_writer(sys.stderr, encoding, errors, force_writable=True)


def _wrap_io_open(
    file: str | os.PathLike[str] | int,
    mode: str,
    encoding: str | None,
    errors: str | None,
) -> t.IO[t.Any]:
    """Handles not passing ``encoding`` and ``errors`` in binary mode."""
    if "b" in mode:
        return open(file, mode)

    return open(file, mode, encoding=encoding, errors=errors)


def open_stream(
    filename: str | os.PathLike[str],
    mode: str = "r",
    encoding: str | None = None,
    errors: str | None = "strict",
    atomic: bool = False,
) -> tuple[t.IO[t.Any], bool]:
    binary = "b" in mode
    filename = os.fspath(filename)

    # Standard streams first. These are simple because they ignore the
    # atomic flag. Use fsdecode to handle Path("-").
    if os.fsdecode(filename) == "-":
        if any(m in mode for m in ["w", "a", "x"]):
            if binary:
                return get_binary_stdout(), False
            return get_text_stdout(encoding=encoding, errors=errors), False
        if binary:
            return get_binary_stdin(), False
        return get_text_stdin(encoding=encoding, errors=errors), False

    # Non-atomic writes directly go out through the regular open functions.
    if not atomic:
        return _wrap_io_open(filename, mode, encoding, errors), True

    # Some usability stuff for atomic writes
    if "a" in mode:
        raise ValueError(
            "Appending to an existing file is not supported, because that"
            " would involve an expensive `copy`-operation to a temporary"
            " file. Open the file in normal `w`-mode and copy explicitly"
            " if that's what you're after."
        )
    if "x" in mode:
        raise ValueError("Use the `overwrite`-parameter instead.")
    if "w" not in mode:
        raise ValueError("Atomic writes only make sense with `w`-mode.")

    # Atomic writes are more complicated.  They work by opening a file
    # as a proxy in the same folder and then using the fdopen
    # functionality to wrap it in a Python file.  Then we wrap it in an
    # atomic file that moves the file over on close.
    import errno
    import random

    try:
        perm: int | None = os.stat(filename).st_mode
    except OSError:
        perm = None

    flags = os.O_RDWR | os.O_CREAT | os.O_EXCL

    if binary:
        flags |= getattr(os, "O_BINARY", 0)

    while True:
        tmp_filename = os.path.join(
            os.path.dirname(filename),
            f".__atomic-write{random.randrange(1 << 32):08x}",
        )
        try:
            fd = os.open(tmp_filename, flags, 0o666 if perm is None else perm)
            break
        except OSError as e:
            if e.errno == errno.EEXIST or (
                os.name == "nt"
                and e.errno == errno.EACCES
                and os.path.isdir(e.filename)
                and os.access(e.filename, os.W_OK)
            ):
                continue
            raise

    if perm is not None:
        os.chmod(tmp_filename, perm)  # in case perm includes bits in umask

    f = _wrap_io_open(fd, mode, encoding, errors)
    af = _AtomicFile(f, tmp_filename, os.path.realpath(filename))
    return t.cast(t.IO[t.Any], af), True


class _AtomicFile:
    def __init__(self, f: t.IO[t.Any], tmp_filename: str, real_filename: str) -> None:
        self._f = f
        self._tmp_filename = tmp_filename
        self._real_filename = real_filename
        self.closed = False

    @property
    def name(self) -> str:
        return self._real_filename

    def close(self, delete: bool = False) -> None:
        if self.closed:
            return
        self._f.close()
        os.replace(self._tmp_filename, self._real_filename)
        self.closed = True

    def __getattr__(self, name: str) -> t.Any:
        return getattr(self._f, name)

    def __enter__(self) -> _AtomicFile:
        return self

    def __exit__(
        self,
        exc_type: type[BaseException] | None,
        exc_value: BaseException | None,
        tb: TracebackType | None,
    ) -> None:
        self.close(delete=exc_type is not None)

    def __repr__(self) -> str:
        return repr(self._f)


def strip_ansi(value: str) -> str:
    return _ansi_re.sub("", value)


def _is_jupyter_kernel_output(stream: t.IO[t.Any]) -> bool:
    while isinstance(stream, (_FixupStream, _NonClosingTextIOWrapper)):
        stream = stream._stream

    return stream.__class__.__module__.startswith("ipykernel.")


def should_strip_ansi(
    stream: t.IO[t.Any] | None = None, color: bool | None = None
) -> bool:
    if color is None:
        if stream is None:
            stream = sys.stdin
        elif hasattr(stream, "color"):
            # ._termui_impl.MaybeStripAnsi handles stripping ansi itself,
            # so we don't need to strip it here
            return False
        return not isatty(stream) and not _is_jupyter_kernel_output(stream)
    return not color


# Double check is needed so mypy does not analyze this on Linux.
if sys.platform.startswith("win") and WIN:
    from ._winconsole import _get_windows_console_stream

    def _get_argv_encoding() -> str:
        import locale

        return locale.getpreferredencoding()

else:

    def _get_argv_encoding() -> str:
        return getattr(sys.stdin, "encoding", None) or sys.getfilesystemencoding()

    def _get_windows_console_stream(
        f: t.TextIO, encoding: str | None, errors: str | None
    ) -> t.TextIO | None:
        return None


def term_len(x: str) -> int:
    return len(strip_ansi(x))


def isatty(stream: t.IO[t.Any]) -> bool:
    try:
        return stream.isatty()
    except Exception:
        return False


def _make_cached_stream_func(
    src_func: t.Callable[[], t.TextIO | None],
    wrapper_func: t.Callable[[], t.TextIO],
) -> t.Callable[[], t.TextIO | None]:
    cache: cabc.MutableMapping[t.TextIO, t.TextIO] = WeakKeyDictionary()

    def func() -> t.TextIO | None:
        stream = src_func()

        if stream is None:
            return None

        try:
            rv = cache.get(stream)
        except Exception:
            rv = None
        if rv is not None:
            return rv
        rv = wrapper_func()
        try:
            cache[stream] = rv
        except Exception:
            pass
        return rv

    return func


_default_text_stdin = _make_cached_stream_func(lambda: sys.stdin, get_text_stdin)
_default_text_stdout = _make_cached_stream_func(lambda: sys.stdout, get_text_stdout)
_default_text_stderr = _make_cached_stream_func(lambda: sys.stderr, get_text_stderr)


binary_streams: cabc.Mapping[str, t.Callable[[], t.BinaryIO]] = {
    "stdin": get_binary_stdin,
    "stdout": get_binary_stdout,
    "stderr": get_binary_stderr,
}

text_streams: cabc.Mapping[str, t.Callable[[str | None, str | None], t.TextIO]] = {
    "stdin": get_text_stdin,
    "stdout": get_text_stdout,
    "stderr": get_text_stderr,
}

// eslint-disable-next-line @typescript-eslint/naming-convention
export type URLOptions = {
	href?: string;
	protocol?: string;
	host?: string;
	hostname?: string;
	port?: string | number;
	pathname?: string;
	search?: string;
	searchParams?: unknown;
	path?: string;
};

const keys: Array<Exclude<keyof URLOptions, 'searchParams' | 'path'>> = [
	'protocol',
	'host',
	'hostname',
	'port',
	'pathname',
	'search',
];

export default function optionsToUrl(origin: string, options: URLOptions): URL {
	if (options.path) {
		if (options.pathname) {
			throw new TypeError('Parameters `path` and `pathname` are mutually exclusive.');
		}

		if (options.search) {
			throw new TypeError('Parameters `path` and `search` are mutually exclusive.');
		}

		if (options.searchParams) {
			throw new TypeError('Parameters `path` and `searchParams` are mutually exclusive.');
		}
	}

	if (options.search && options.searchParams) {
		throw new TypeError('Parameters `search` and `searchParams` are mutually exclusive.');
	}

	if (!origin) {
		if (!options.protocol) {
			throw new TypeError('No URL protocol specified');
		}

		origin = `${options.protocol}//${options.hostname ?? options.host ?? ''}`;
	}

	const url = new URL(origin);

	if (options.path) {
		const searchIndex = options.path.indexOf('?');
		if (searchIndex === -1) {
			options.pathname = options.path;
		} else {
			options.pathname = options.path.slice(0, searchIndex);
			options.search = options.path.slice(searchIndex + 1);
		}

		delete options.path;
	}

	for (const key of keys) {
		if (options[key]) {
			url[key] = options[key].toString();
		}
	}

	return url;
}

'use strict'

var express = require('../')
  , request = require('supertest');

describe('req', function(){
  describe('.route', function(){
    it('should be the executed Route', function(done){
      var app = express();

      app.get('/user/:id{/:op}', function(req, res, next){
        res.header('path-1', req.route.path)
        next();
      });

      app.get('/user/:id/edit', function(req, res){
        res.header('path-2', req.route.path)
        res.end();
      });

      request(app)
        .get('/user/12/edit')
        .expect('path-1', '/user/:id{/:op}')
        .expect('path-2', '/user/:id/edit')
        .expect(200, done)
    })
  })
})

import {randomUUID} from 'node:crypto';
import diagnosticsChannel from 'node:diagnostics_channel';
import type {Timings} from './utils/timer.js';
import type {RequestError} from './errors.js';

const channels = {
	requestCreate: diagnosticsChannel.channel('got:request:create'),
	requestStart: diagnosticsChannel.channel('got:request:start'),
	responseStart: diagnosticsChannel.channel('got:response:start'),
	responseEnd: diagnosticsChannel.channel('got:response:end'),
	retry: diagnosticsChannel.channel('got:request:retry'),
	error: diagnosticsChannel.channel('got:request:error'),
	redirect: diagnosticsChannel.channel('got:response:redirect'),
};

export type RequestId = string;

/**
Message for the `got:request:create` diagnostic channel.

Emitted when a request is created.
*/
export type DiagnosticRequestCreate = {
	requestId: RequestId;
	url: string;
	method: string;
};

/**
Message for the `got:request:start` diagnostic channel.

Emitted before the native HTTP request is sent.
*/
export type DiagnosticRequestStart = {
	requestId: RequestId;
	url: string;
	method: string;
	headers: Record<string, string | string[] | undefined>;
};

/**
Message for the `got:response:start` diagnostic channel.

Emitted when response headers are received.
*/
export type DiagnosticResponseStart = {
	requestId: RequestId;
	url: string;
	statusCode: number;
	headers: Record<string, string | string[] | undefined>;
	isFromCache: boolean;
};

/**
Message for the `got:response:end` diagnostic channel.

Emitted when the response completes.
*/
export type DiagnosticResponseEnd = {
	requestId: RequestId;
	url: string;
	statusCode: number;
	bodySize?: number;
	timings?: Timings;
};

/**
Message for the `got:request:retry` diagnostic channel.

Emitted when retrying a request.
*/
export type DiagnosticRequestRetry = {
	requestId: RequestId;
	retryCount: number;
	error: RequestError;
	delay: number;
};

/**
Message for the `got:request:error` diagnostic channel.

Emitted when a request fails.
*/
export type DiagnosticRequestError = {
	requestId: RequestId;
	url: string;
	error: RequestError;
	timings?: Timings;
};

/**
Message for the `got:response:redirect` diagnostic channel.

Emitted when following a redirect.
*/
export type DiagnosticResponseRedirect = {
	requestId: RequestId;
	fromUrl: string;
	toUrl: string;
	statusCode: number;
};

export function generateRequestId(): RequestId {
	return randomUUID();
}

const publishToChannel = (channel: diagnosticsChannel.Channel, message: unknown): void => {
	if (channel.hasSubscribers) {
		channel.publish(message);
	}
};

export function publishRequestCreate(message: DiagnosticRequestCreate): void {
	publishToChannel(channels.requestCreate, message);
}

export function publishRequestStart(message: DiagnosticRequestStart): void {
	publishToChannel(channels.requestStart, message);
}

export function publishResponseStart(message: DiagnosticResponseStart): void {
	publishToChannel(channels.responseStart, message);
}

export function publishResponseEnd(message: DiagnosticResponseEnd): void {
	publishToChannel(channels.responseEnd, message);
}

export function publishRetry(message: DiagnosticRequestRetry): void {
	publishToChannel(channels.retry, message);
}

export function publishError(message: DiagnosticRequestError): void {
	publishToChannel(channels.error, message);
}

export function publishRedirect(message: DiagnosticResponseRedirect): void {
	publishToChannel(channels.redirect, message);
}

import importlib.abc
import importlib.machinery
import importlib.util
import os
import shutil
import sys
import tempfile
import time
import weakref
from pathlib import Path

import pytest

from jinja2 import Environment
from jinja2 import loaders
from jinja2 import PackageLoader
from jinja2.exceptions import TemplateNotFound
from jinja2.loaders import split_template_path


class TestLoaders:
    def test_dict_loader(self, dict_loader):
        env = Environment(loader=dict_loader)
        tmpl = env.get_template("justdict.html")
        assert tmpl.render().strip() == "FOO"
        pytest.raises(TemplateNotFound, env.get_template, "missing.html")

    def test_package_loader(self, package_loader):
        env = Environment(loader=package_loader)
        tmpl = env.get_template("test.html")
        assert tmpl.render().strip() == "BAR"
        pytest.raises(TemplateNotFound, env.get_template, "missing.html")

    def test_filesystem_loader_overlapping_names(self, filesystem_loader):
        t2_dir = Path(filesystem_loader.searchpath[0]) / ".." / "templates2"
        # Make "foo" show up before "foo/test.html".
        filesystem_loader.searchpath.insert(0, t2_dir)
        e = Environment(loader=filesystem_loader)
        e.get_template("foo")
        # This would raise NotADirectoryError if "t2/foo" wasn't skipped.
        e.get_template("foo/test.html")

    def test_choice_loader(self, choice_loader):
        env = Environment(loader=choice_loader)
        tmpl = env.get_template("justdict.html")
        assert tmpl.render().strip() == "FOO"
        tmpl = env.get_template("test.html")
        assert tmpl.render().strip() == "BAR"
        pytest.raises(TemplateNotFound, env.get_template, "missing.html")

    def test_function_loader(self, function_loader):
        env = Environment(loader=function_loader)
        tmpl = env.get_template("justfunction.html")
        assert tmpl.render().strip() == "FOO"
        pytest.raises(TemplateNotFound, env.get_template, "missing.html")

    def test_prefix_loader(self, prefix_loader):
        env = Environment(loader=prefix_loader)
        tmpl = env.get_template("a/test.html")
        assert tmpl.render().strip() == "BAR"
        tmpl = env.get_template("b/justdict.html")
        assert tmpl.render().strip() == "FOO"
        pytest.raises(TemplateNotFound, env.get_template, "missing")

    def test_caching(self):
        changed = False

        class TestLoader(loaders.BaseLoader):
            def get_source(self, environment, template):
                return "foo", None, lambda: not changed

        env = Environment(loader=TestLoader(), cache_size=-1)
        tmpl = env.get_template("template")
        assert tmpl is env.get_template("template")
        changed = True
        assert tmpl is not env.get_template("template")
        changed = False

    def test_no_cache(self):
        mapping = {"foo": "one"}
        env = Environment(loader=loaders.DictLoader(mapping), cache_size=0)
        assert env.get_template("foo") is not env.get_template("foo")

    def test_limited_size_cache(self):
        mapping = {"one": "foo", "two": "bar", "three": "baz"}
        loader = loaders.DictLoader(mapping)
        env = Environment(loader=loader, cache_size=2)
        t1 = env.get_template("one")
        t2 = env.get_template("two")
        assert t2 is env.get_template("two")
        assert t1 is env.get_template("one")
        env.get_template("three")
        loader_ref = weakref.ref(loader)
        assert (loader_ref, "one") in env.cache
        assert (loader_ref, "two") not in env.cache
        assert (loader_ref, "three") in env.cache

    def test_cache_loader_change(self):
        loader1 = loaders.DictLoader({"foo": "one"})
        loader2 = loaders.DictLoader({"foo": "two"})
        env = Environment(loader=loader1, cache_size=2)
        assert env.get_template("foo").render() == "one"
        env.loader = loader2
        assert env.get_template("foo").render() == "two"

    def test_dict_loader_cache_invalidates(self):
        mapping = {"foo": "one"}
        env = Environment(loader=loaders.DictLoader(mapping))
        assert env.get_template("foo").render() == "one"
        mapping["foo"] = "two"
        assert env.get_template("foo").render() == "two"

    def test_split_template_path(self):
        assert split_template_path("foo/bar") == ["foo", "bar"]
        assert split_template_path("./foo/bar") == ["foo", "bar"]
        pytest.raises(TemplateNotFound, split_template_path, "../foo")


class TestFileSystemLoader:
    searchpath = (Path(__file__) / ".." / "res" / "templates").resolve()

    @staticmethod
    def _test_common(env):
        tmpl = env.get_template("test.html")
        assert tmpl.render().strip() == "BAR"
        tmpl = env.get_template("foo/test.html")
        assert tmpl.render().strip() == "FOO"
        pytest.raises(TemplateNotFound, env.get_template, "missing.html")

    def test_searchpath_as_str(self):
        filesystem_loader = loaders.FileSystemLoader(str(self.searchpath))

        env = Environment(loader=filesystem_loader)
        self._test_common(env)

    def test_searchpath_as_pathlib(self):
        filesystem_loader = loaders.FileSystemLoader(self.searchpath)
        env = Environment(loader=filesystem_loader)
        self._test_common(env)

    def test_searchpath_as_list_including_pathlib(self):
        filesystem_loader = loaders.FileSystemLoader(
            ["/tmp/templates", self.searchpath]
        )
        env = Environment(loader=filesystem_loader)
        self._test_common(env)

    def test_caches_template_based_on_mtime(self):
        filesystem_loader = loaders.FileSystemLoader(self.searchpath)

        env = Environment(loader=filesystem_loader)
        tmpl1 = env.get_template("test.html")
        tmpl2 = env.get_template("test.html")
        assert tmpl1 is tmpl2

        os.utime(self.searchpath / "test.html", (time.time(), time.time()))
        tmpl3 = env.get_template("test.html")
        assert tmpl1 is not tmpl3

    @pytest.mark.parametrize(
        ("encoding", "expect"),
        [
            ("utf-8", "文字化け"),
            ("iso-8859-1", "æ\x96\x87\xe5\xad\x97\xe5\x8c\x96\xe3\x81\x91"),
        ],
    )
    def test_uses_specified_encoding(self, encoding, expect):
        loader = loaders.FileSystemLoader(self.searchpath, encoding=encoding)
        e = Environment(loader=loader)
        t = e.get_template("mojibake.txt")
        assert t.render() == expect

    def test_filename_normpath(self):
        """Nested template names should only contain ``os.sep`` in the
        loaded filename.
        """
        loader = loaders.FileSystemLoader(self.searchpath)
        e = Environment(loader=loader)
        t = e.get_template("foo/test.html")
        assert t.filename == str(self.searchpath / "foo" / "test.html")

    def test_error_includes_paths(self, env, filesystem_loader):
        env.loader = filesystem_loader

        with pytest.raises(TemplateNotFound) as info:
            env.get_template("missing")

        e_str = str(info.value)
        assert e_str.startswith("'missing' not found in search path: ")

        filesystem_loader.searchpath.append("other")

        with pytest.raises(TemplateNotFound) as info:
            env.get_template("missing")

        e_str = str(info.value)
        assert e_str.startswith("'missing' not found in search paths: ")
        assert ", 'other'" in e_str


class TestModuleLoader:
    archive = None
    mod_env = None

    def compile_down(self, prefix_loader, zip="deflated"):
        log = []
        self.reg_env = Environment(loader=prefix_loader)
        if zip is not None:
            fd, self.archive = tempfile.mkstemp(suffix=".zip")
            os.close(fd)
        else:
            self.archive = tempfile.mkdtemp()
        self.reg_env.compile_templates(self.archive, zip=zip, log_function=log.append)
        self.mod_env = Environment(loader=loaders.ModuleLoader(self.archive))
        return "".join(log)

    def teardown_method(self):
        if self.archive is not None:
            if os.path.isfile(self.archive):
                os.remove(self.archive)
            else:
                shutil.rmtree(self.archive)
            self.archive = None
            self.mod_env = None

    def test_log(self, prefix_loader):
        log = self.compile_down(prefix_loader)
        assert (
            'Compiled "a/foo/test.html" as '
            "tmpl_a790caf9d669e39ea4d280d597ec891c4ef0404a" in log
        )
        assert "Finished compiling templates" in log
        assert (
            'Could not compile "a/syntaxerror.html": '
            "Encountered unknown tag 'endif'" in log
        )

    def _test_common(self):
        tmpl1 = self.reg_env.get_template("a/test.html")
        tmpl2 = self.mod_env.get_template("a/test.html")
        assert tmpl1.render() == tmpl2.render()

        tmpl1 = self.reg_env.get_template("b/justdict.html")
        tmpl2 = self.mod_env.get_template("b/justdict.html")
        assert tmpl1.render() == tmpl2.render()

    def test_deflated_zip_compile(self, prefix_loader):
        self.compile_down(prefix_loader, zip="deflated")
        self._test_common()

    def test_stored_zip_compile(self, prefix_loader):
        self.compile_down(prefix_loader, zip="stored")
        self._test_common()

    def test_filesystem_compile(self, prefix_loader):
        self.compile_down(prefix_loader, zip=None)
        self._test_common()

    def test_weak_references(self, prefix_loader):
        self.compile_down(prefix_loader)
        self.mod_env.get_template("a/test.html")
        key = loaders.ModuleLoader.get_template_key("a/test.html")
        name = self.mod_env.loader.module.__name__

        assert hasattr(self.mod_env.loader.module, key)
        assert name in sys.modules

        # unset all, ensure the module is gone from sys.modules
        self.mod_env = None

        try:
            import gc

            gc.collect()
        except BaseException:
            pass

        assert name not in sys.modules

    def test_choice_loader(self, prefix_loader):
        self.compile_down(prefix_loader)
        self.mod_env.loader = loaders.ChoiceLoader(
            [self.mod_env.loader, loaders.DictLoader({"DICT_SOURCE": "DICT_TEMPLATE"})]
        )
        tmpl1 = self.mod_env.get_template("a/test.html")
        assert tmpl1.render() == "BAR"
        tmpl2 = self.mod_env.get_template("DICT_SOURCE")
        assert tmpl2.render() == "DICT_TEMPLATE"

    def test_prefix_loader(self, prefix_loader):
        self.compile_down(prefix_loader)
        self.mod_env.loader = loaders.PrefixLoader(
            {
                "MOD": self.mod_env.loader,
                "DICT": loaders.DictLoader({"test.html": "DICT_TEMPLATE"}),
            }
        )
        tmpl1 = self.mod_env.get_template("MOD/a/test.html")
        assert tmpl1.render() == "BAR"
        tmpl2 = self.mod_env.get_template("DICT/test.html")
        assert tmpl2.render() == "DICT_TEMPLATE"

    def test_path_as_pathlib(self, prefix_loader):
        self.compile_down(prefix_loader)

        mod_path = self.mod_env.loader.module.__path__[0]
        mod_loader = loaders.ModuleLoader(Path(mod_path))
        self.mod_env = Environment(loader=mod_loader)

        self._test_common()

    def test_supports_pathlib_in_list_of_paths(self, prefix_loader):
        self.compile_down(prefix_loader)

        mod_path = self.mod_env.loader.module.__path__[0]
        mod_loader = loaders.ModuleLoader([Path(mod_path), "/tmp/templates"])
        self.mod_env = Environment(loader=mod_loader)

        self._test_common()


@pytest.fixture()
def package_dir_loader(monkeypatch):
    monkeypatch.syspath_prepend(Path(__file__).parent)
    return PackageLoader("res")


@pytest.mark.parametrize(
    ("template", "expect"), [("foo/test.html", "FOO"), ("test.html", "BAR")]
)
def test_package_dir_source(package_dir_loader, template, expect):
    source, name, up_to_date = package_dir_loader.get_source(None, template)
    assert source.rstrip() == expect
    assert name.endswith(os.path.join(*split_template_path(template)))
    assert up_to_date()


def test_package_dir_list(package_dir_loader):
    templates = package_dir_loader.list_templates()
    assert "foo/test.html" in templates
    assert "test.html" in templates


@pytest.fixture()
def package_file_loader(monkeypatch):
    monkeypatch.syspath_prepend(Path(__file__).parent / "res")
    return PackageLoader("__init__")


@pytest.mark.parametrize(
    ("template", "expect"), [("foo/test.html", "FOO"), ("test.html", "BAR")]
)
def test_package_file_source(package_file_loader, template, expect):
    source, name, up_to_date = package_file_loader.get_source(None, template)
    assert source.rstrip() == expect
    assert name.endswith(os.path.join(*split_template_path(template)))
    assert up_to_date()


def test_package_file_list(package_file_loader):
    templates = package_file_loader.list_templates()
    assert "foo/test.html" in templates
    assert "test.html" in templates


@pytest.fixture()
def package_zip_loader(monkeypatch):
    package_zip = (Path(__file__) / ".." / "res" / "package.zip").resolve()
    monkeypatch.syspath_prepend(package_zip)
    return PackageLoader("t_pack")


@pytest.mark.parametrize(
    ("template", "expect"), [("foo/test.html", "FOO"), ("test.html", "BAR")]
)
def test_package_zip_source(package_zip_loader, template, expect):
    source, name, up_to_date = package_zip_loader.get_source(None, template)
    assert source.rstrip() == expect
    assert name.endswith(os.path.join(*split_template_path(template)))
    assert up_to_date is None


@pytest.mark.xfail(
    sys.implementation.name == "pypy",
    reason="zipimporter doesn't have a '_files' attribute",
    raises=TypeError,
)
def test_package_zip_list(package_zip_loader):
    assert package_zip_loader.list_templates() == ["foo/test.html", "test.html"]


@pytest.mark.parametrize("package_path", ["", ".", "./"])
def test_package_zip_omit_curdir(package_zip_loader, package_path):
    """PackageLoader should not add or include "." or "./" in the root
    path, it is invalid in zip paths.
    """
    loader = PackageLoader("t_pack", package_path)
    assert loader.package_path == ""
    source, _, _ = loader.get_source(None, "templates/foo/test.html")
    assert source.rstrip() == "FOO"


def test_pep_451_import_hook():
    class ImportHook(importlib.abc.MetaPathFinder, importlib.abc.Loader):
        def find_spec(self, name, path=None, target=None):
            if name != "res":
                return None

            spec = importlib.machinery.PathFinder.find_spec(name)
            return importlib.util.spec_from_file_location(
                name,
                spec.origin,
                loader=self,
                submodule_search_locations=spec.submodule_search_locations,
            )

        def create_module(self, spec):
            return None  # default behaviour is fine

        def exec_module(self, module):
            return None  # we need this to satisfy the interface, it's wrong

    # ensure we restore `sys.meta_path` after putting in our loader
    before = sys.meta_path[:]

    try:
        sys.meta_path.insert(0, ImportHook())
        package_loader = PackageLoader("res")
        assert "test.html" in package_loader.list_templates()
    finally:
        sys.meta_path[:] = before


def test_package_loader_no_dir() -> None:
    with pytest.raises(ValueError, match="could not find a 'templates' directory"):
        PackageLoader("jinja2")

import test from 'ava';
import {getUnixSocketPath} from '../source/core/utils/is-unix-socket-url.js';

test('returns socket path for unix: protocol URLs', t => {
	const url = new URL('unix:/foo/bar.sock:/path');
	t.is(getUnixSocketPath(url), '/foo/bar.sock');
});

test('returns socket path for http://unix URLs', t => {
	const url = new URL('http://unix/foo/bar.sock:/path');
	t.is(getUnixSocketPath(url), '/foo/bar.sock');
});

test('returns different socket paths for different sockets', t => {
	const url1 = new URL('http://unix/tmp/socket1:/path');
	const url2 = new URL('http://unix/tmp/socket2:/path');

	t.is(getUnixSocketPath(url1), '/tmp/socket1');
	t.is(getUnixSocketPath(url2), '/tmp/socket2');
	t.not(getUnixSocketPath(url1), getUnixSocketPath(url2));
});

test('returns undefined for regular HTTP URLs', t => {
	const url = new URL('http://example.com/path');
	t.is(getUnixSocketPath(url), undefined);
});

test('returns undefined for HTTPS URLs', t => {
	const url = new URL('https://example.com/path');
	t.is(getUnixSocketPath(url), undefined);
});

test('handles socket paths with special characters', t => {
	const url = new URL('http://unix/tmp/my-app.sock:/api/endpoint');
	t.is(getUnixSocketPath(url), '/tmp/my-app.sock');
});

import os
import pathlib
import stat

import pytest

import click
from click._compat import WIN


def test_open_file(runner, tmp_path):
    @click.command()
    @click.argument("filename")
    def cli(filename):
        with click.open_file(filename) as f:
            click.echo(f.read())

        click.echo("meep")

    hello = tmp_path / "hello.txt"
    hello.write_text("Cool stuff")

    result = runner.invoke(cli, [str(hello)])
    assert result.exception is None
    assert result.output == "Cool stuff\nmeep\n"

    result = runner.invoke(cli, ["-"], input="foobar")
    assert result.exception is None
    assert result.output == "foobar\nmeep\n"


def test_open_file_pathlib_dash(runner):
    @click.command()
    @click.argument(
        "filename", type=click.Path(allow_dash=True, path_type=pathlib.Path)
    )
    def cli(filename):
        click.echo(str(type(filename)))

        with click.open_file(filename) as f:
            click.echo(f.read())

        result = runner.invoke(cli, ["-"], input="value")
        assert result.exception is None
        assert result.output == "pathlib.Path\nvalue\n"


def test_open_file_ignore_errors_stdin(runner):
    @click.command()
    @click.argument("filename")
    def cli(filename):
        with click.open_file(filename, errors="ignore") as f:
            click.echo(f.read())

    result = runner.invoke(cli, ["-"], input=os.urandom(16))
    assert result.exception is None


def test_open_file_respects_ignore(tmp_path):
    path = tmp_path / "test.txt"
    path.write_text("Hello world!")

    with click.open_file(str(path), encoding="utf8", errors="ignore") as f:
        assert f.errors == "ignore"


def test_open_file_ignore_invalid_utf8(tmp_path):
    path = tmp_path / "test.txt"
    path.write_bytes(b"\xe2\x28\xa1")

    with click.open_file(str(path), encoding="utf8", errors="ignore") as f:
        f.read()


def test_open_file_ignore_no_encoding(tmp_path):
    path = tmp_path / "test.bin"
    path.write_bytes(os.urandom(16))

    with click.open_file(str(path), errors="ignore") as f:
        f.read()


@pytest.mark.skipif(WIN, reason="os.chmod() is not fully supported on Windows.")
@pytest.mark.parametrize("permissions", [0o400, 0o444, 0o600, 0o644])
def test_open_file_atomic_permissions_existing_file(runner, tmp_path, permissions):
    existing = tmp_path / "existing.txt"
    existing.write_text("content")
    os.chmod(existing, permissions)

    @click.command()
    @click.argument("filename")
    def cli(filename):
        click.open_file(filename, "w", atomic=True).close()

    result = runner.invoke(cli, [str(existing)])
    assert result.exception is None
    assert stat.S_IMODE(os.stat(existing).st_mode) == permissions


@pytest.mark.skipif(WIN, reason="os.stat() is not fully supported on Windows.")
def test_open_file_atomic_permissions_new_file(runner, tmp_path):
    @click.command()
    @click.argument("filename")
    def cli(filename):
        click.open_file(filename, "w", atomic=True).close()

    # Create a test file to get the expected permissions for new files
    # according to the current umask.
    probe = tmp_path / "test.txt"
    with open(probe, "w"):
        pass
    permissions = stat.S_IMODE(os.stat(probe).st_mode)

    new = tmp_path / "new.txt"
    result = runner.invoke(cli, [str(new)])
    assert result.exception is None
    assert stat.S_IMODE(os.stat(new).st_mode) == permissions

#!/usr/bin/env python3

from scriptCommon import catchPath
import os
import subprocess

# ---------------------------------------------------
# Update code examples
# ---------------------------------------------------
# For info on mdsnippets, see https://github.com/SimonCropp/MarkdownSnippets

# install dotnet SDK from http://go.microsoft.com/fwlink/?LinkID=798306&clcid=0x409
# Then install MarkdownSnippets.Tool with
#   dotnet tool install -g MarkdownSnippets.Tool
# To update:
#   dotnet tool update  -g MarkdownSnippets.Tool
# To uninstall (e.g. to downgrade to a lower version)
# dotnet tool uninstall -g MarkdownSnippets.Tool

os.chdir(catchPath)

subprocess.run('dotnet tool update  -g MarkdownSnippets.Tool --version 21.2.0', shell=True, check=True)
subprocess.run('mdsnippets', shell=True, check=True)

from __future__ import annotations

import collections.abc as cabc
import textwrap
from contextlib import contextmanager

from ._compat import _ansi_re
from ._compat import term_len


def _truncate_visible(text: str, n: int) -> str:
    """Return the longest prefix of ``text`` containing at most ``n`` visible
    characters.

    ANSI escape sequences inside the prefix are kept intact and do not count
    toward the visible width. A cut is never placed inside an escape sequence.
    """
    if n <= 0:
        return ""

    visible = 0
    i = 0
    cut = 0
    end = len(text)
    while i < end:
        m = _ansi_re.match(text, i)
        if m is not None:
            i = m.end()
            continue
        visible += 1
        i += 1
        cut = i
        if visible >= n:
            break
    return text[:cut]


class TextWrapper(textwrap.TextWrapper):
    """``textwrap.TextWrapper`` variant that measures widths by visible
    character count.

    ANSI escape sequences embedded in chunks, indents, or the placeholder are
    excluded from the width budget. Without this, styled help text (a styled
    ``Usage:`` prefix, a colorized option name, ...) would be wrapped earlier
    than its visible length warrants and tokens would split mid-word.
    """

    def _handle_long_word(
        self,
        reversed_chunks: list[str],
        cur_line: list[str],
        cur_len: int,
        width: int,
    ) -> None:
        space_left = max(width - cur_len, 1)

        if self.break_long_words:
            last = reversed_chunks[-1]
            cut = _truncate_visible(last, space_left)
            res = last[len(cut) :]
            cur_line.append(cut)
            reversed_chunks[-1] = res
        elif not cur_line:
            cur_line.append(reversed_chunks.pop())

    def _wrap_chunks(self, chunks: list[str]) -> list[str]:
        """Wrap chunks counting widths in visible characters.

        Mirrors the algorithm of :meth:`textwrap.TextWrapper._wrap_chunks`
        with every width measurement routed through
        :func:`click._compat.term_len` instead of :func:`len`, so ANSI escape
        bytes in chunks, indents, or the placeholder do not inflate the count.

        .. seealso::
            :class:`textwrap.TextWrapper` in the Python standard library documentation:
            https://docs.python.org/3/library/textwrap.html#textwrap.TextWrapper

            Reference implementation in CPython:
            https://github.com/python/cpython/blob/main/Lib/textwrap.py
        """
        lines: list[str] = []
        if self.width <= 0:
            raise ValueError(f"invalid width {self.width!r} (must be > 0)")
        if self.max_lines is not None:
            if self.max_lines > 1:
                indent = self.subsequent_indent
            else:
                indent = self.initial_indent
            if term_len(indent) + term_len(self.placeholder.lstrip()) > self.width:
                raise ValueError("placeholder too large for max width")

        chunks.reverse()

        while chunks:
            cur_line: list[str] = []
            cur_len = 0

            if lines:
                indent = self.subsequent_indent
            else:
                indent = self.initial_indent

            width = self.width - term_len(indent)

            if self.drop_whitespace and chunks[-1].strip() == "" and lines:
                del chunks[-1]

            while chunks:
                n = term_len(chunks[-1])

                if cur_len + n <= width:
                    cur_line.append(chunks.pop())
                    cur_len += n

                else:
                    break

            if chunks and term_len(chunks[-1]) > width:
                self._handle_long_word(chunks, cur_line, cur_len, width)
                cur_len = sum(map(term_len, cur_line))

            if self.drop_whitespace and cur_line and cur_line[-1].strip() == "":
                cur_len -= term_len(cur_line[-1])
                del cur_line[-1]

            if cur_line:
                if (
                    self.max_lines is None
                    or len(lines) + 1 < self.max_lines
                    or (
                        not chunks
                        or self.drop_whitespace
                        and len(chunks) == 1
                        and not chunks[0].strip()
                    )
                    and cur_len <= width
                ):
                    lines.append(indent + "".join(cur_line))
                else:
                    while cur_line:
                        if (
                            cur_line[-1].strip()
                            and cur_len + term_len(self.placeholder) <= width
                        ):
                            cur_line.append(self.placeholder)
                            lines.append(indent + "".join(cur_line))
                            break
                        cur_len -= term_len(cur_line[-1])
                        del cur_line[-1]
                    else:
                        if lines:
                            prev_line = lines[-1].rstrip()
                            if (
                                term_len(prev_line) + term_len(self.placeholder)
                                <= self.width
                            ):
                                lines[-1] = prev_line + self.placeholder
                                break
                        lines.append(indent + self.placeholder.lstrip())
                    break

        return lines

    @contextmanager
    def extra_indent(self, indent: str) -> cabc.Iterator[None]:
        old_initial_indent = self.initial_indent
        old_subsequent_indent = self.subsequent_indent
        self.initial_indent += indent
        self.subsequent_indent += indent

        try:
            yield
        finally:
            self.initial_indent = old_initial_indent
            self.subsequent_indent = old_subsequent_indent

    def indent_only(self, text: str) -> str:
        rv = []

        for idx, line in enumerate(text.splitlines()):
            indent = self.initial_indent

            if idx > 0:
                indent = self.subsequent_indent

            rv.append(f"{indent}{line}")

        return "\n".join(rv)

(virtualenv-heading)=

# Virtualenv

## Why Use Virtualenv?

You should use [Virtualenv](https://virtualenv.pypa.io/en/latest/) because:

- It allows you to install multiple versions of the same dependency.
- If you have an operating system version of Python, it prevents you from changing its dependencies and potentially
  messing up your os.

## How to Use Virtualenv

Create your project folder, then a virtualenv within it:

```console
$ mkdir myproject
$ cd myproject
$ python3 -m venv .venv
```

Now, whenever you want to work on a project, you only have to activate the corresponding environment.


```{eval-rst}
.. tabs::

    .. group-tab:: OSX/Linux

        .. code-block:: text

            $ . .venv/bin/activate
            (venv) $

    .. group-tab:: Windows

        .. code-block:: text

            > .venv\scripts\activate
            (venv) >
```

You are now using your virtualenv (notice how the prompt of your shell has changed to show the active environment).

To install packages in the virtual environment:

```console
$ pip install click
```

And if you want to stop using the virtualenv, use the following command:

```console
$ deactivate
```

After doing this, the prompt of your shell should be as familiar as before.

'use strict'

var express = require('../../..');

var apiv1 = express.Router();

apiv1.get('/', function(req, res) {
  res.send('Hello from APIv1 root route.');
});

apiv1.get('/users', function(req, res) {
  res.send('List of APIv1 users.');
});

module.exports = apiv1;

<a id="top"></a>
# Reporters

Reporters are a customization point for most of Catch2's output, e.g.
formatting and writing out [assertions (whether passing or failing),
sections, test cases, benchmarks, and so on](reporter-events.md#top).

Catch2 comes with a bunch of reporters by default (currently 9), and
you can also write your own reporter. Because multiple reporters can
be active at the same time, your own reporters do not even have to handle
all reporter event, just the ones you are interested in, e.g. benchmarks.


## Using different reporters

You can see which reporters are available by running the test binary
with `--list-reporters`. You can then pick one of them with the [`-r`,
`--reporter` option](command-line.md#choosing-a-reporter-to-use), followed
by the name of the desired reporter, like so:

```
--reporter xml
```

You can also select multiple reporters to be used at the same time.
In that case you should read the [section on using multiple
reporters](#multiple-reporters) to avoid any surprises from doing so.


<a id="multiple-reporters"></a>
## Using multiple reporters

> Support for having multiple parallel reporters was [introduced](https://github.com/catchorg/Catch2/pull/2183) in Catch2 3.0.1

Catch2 supports using multiple reporters at the same time while having
them write into different destinations. The two main uses of this are

* having both human-friendly and machine-parseable (e.g. in JUnit format)
  output from one run of binary
* having "partial" reporters that are highly specialized, e.g. having one
  reporter that writes out benchmark results as markdown tables and does
  nothing else, while also having standard testing output separately

Specifying multiple reporter looks like this:
```
--reporter JUnit::out=result-junit.xml --reporter console::out=-::colour-mode=ansi::verbosity=quiet
```

This tells Catch2 to use two reporters, `JUnit` reporter that writes
its machine-readable XML output to file `result-junit.xml`, and the
`console` reporter that writes its user-friendly output to stdout, uses
ANSI colour codes for colouring the output and is set to "quiet" verbosity.

Using multiple reporters (or one reporter and one-or-more [event
listeners](event-listeners.md#top)) can have surprisingly complex semantics
when using customization points provided to reporters by Catch2, namely
capturing stdout/stderr from test cases.

As long as at least one reporter (or listener) asks Catch2 to capture
stdout/stderr, captured stdout and stderr will be available to all
reporters and listeners.

Because this might be surprising to the users, if at least one active
_reporter_ is non-capturing, then Catch2 tries to roughly emulate
non-capturing behaviour by printing out the captured stdout/stderr
just before `testCasePartialEnded` event is sent out to the active
reporters and listeners. This means that stdout/stderr is no longer
printed out from tests as it is being written, but instead it is written
out in batch after each runthrough of a test case is finished.



## Writing your own reporter

You can also write your own custom reporter and tell Catch2 to use it.
When writing your reporter, you have two options:

* Derive from `Catch::ReporterBase`. When doing this, you will have
  to provide handling for all [reporter events](reporter-events.md#top).
* Derive from one of the provided [utility reporter bases in
  Catch2](#utility-reporter-bases).

Generally we recommend doing the latter, as it is less work.

Apart from overriding handling of the individual reporter events, reporters
have access to some extra customization points, described below.


### Utility reporter bases

Catch2 currently provides two utility reporter bases:

* `Catch::StreamingReporterBase`
* `Catch::CumulativeReporterBase`

`StreamingReporterBase` is useful for reporters that can format and write
out the events as they come in. It provides (usually empty) implementation
for all reporter events, and if you let it handle the relevant events,
it also handles storing information about active test run and test case.

`CumulativeReporterBase` is a base for reporters that need to see the whole
test run, before they can start writing the output, such as the JUnit
and SonarQube reporters. This post-facto approach requires the assertions
to be stringified when it is finished, so that the assertion can be written
out later. Because the stringification can be expensive, and not all
cumulative reporters need the assertions, this base provides customization
point to change whether the assertions are saved or not, separate for
passing and failing assertions.


_Generally we recommend that if you override a member function from either
of the bases, you call into the base's implementation first. This is not
necessary in all cases, but it is safer and easier._


Writing your own reporter then looks like this:

```cpp
#include <catch2/reporters/catch_reporter_streaming_base.hpp>
#include <catch2/catch_test_case_info.hpp>
#include <catch2/reporters/catch_reporter_registrars.hpp>

#include <iostream>

class PartialReporter : public Catch::StreamingReporterBase {
public:
    using StreamingReporterBase::StreamingReporterBase;

    static std::string getDescription() {
        return "Reporter for testing TestCasePartialStarting/Ended events";
    }

    void testCasePartialStarting(Catch::TestCaseInfo const& testInfo,
                                 uint64_t partNumber) override {
        std::cout << "TestCaseStartingPartial: " << testInfo.name << '#' << partNumber << '\n';
    }

    void testCasePartialEnded(Catch::TestCaseStats const& testCaseStats,
                              uint64_t partNumber) override {
        std::cout << "TestCasePartialEnded: " << testCaseStats.testInfo->name << '#' << partNumber << '\n';
    }
};


CATCH_REGISTER_REPORTER("partial", PartialReporter)
```

This create a simple reporter that responds to `testCasePartial*` events,
and calls itself "partial" reporter, so it can be invoked with
`--reporter partial` command line flag.


### `ReporterPreferences`

Each reporter instance contains instance of `ReporterPreferences`, a type
that holds flags for the behaviour of Catch2 when this reporter run.
Currently there are three customization options:

* `shouldRedirectStdOut` - whether the reporter wants to handle
   writes to stdout/stderr from user code, or not. This is useful for
   reporters that output machine-parseable output, e.g. the JUnit
   reporter, or the XML reporter.
* `shouldReportAllAssertions` - whether the reporter wants to handle
  `assertionEnded` events for passing assertions as well as failing
   assertions. Usually reporters do not report successful assertions
   and don't need them for their output, but sometimes the desired output
   format includes passing assertions even without the `-s` flag.
* `shouldReportAllAssertionStarts` - whether the reporter wants to handle
  `assertionStarting` events. Most reporters do not, and opting out
   explicitly enables a fast-path in Catch2's handling of assertions.

> `shouldReportAllAssertionStarts` was introduced in Catch2 3.9.0


### Per-reporter configuration

> Per-reporter configuration was introduced in Catch2 3.0.1

Catch2 supports some configuration to happen per reporter. The configuration
options fall into one of two categories:

* Catch2-recognized options
* Reporter-specific options

The former is a small set of universal options that Catch2 handles for
the reporters, e.g. output file or console colour mode. The latter are
options that the reporters have to handle themselves, but the keys and
values can be arbitrary strings, as long as they don't contain `::`. This
allows writing reporters that can be significantly customized at runtime.

Reporter-specific options always have to be prefixed with "X" (large
letter X).


### Other expected functionality of a reporter

When writing a custom reporter, there are few more things that you should
keep in mind. These are not important for correctness, but they are
important for the reporter to work _nicely_.

* Catch2 provides a simple verbosity option for users. There are three
  verbosity levels, "quiet", "normal", and "high", and if it makes sense
  for reporter's output format, it should respond to these by changing
  what, and how much, it writes out.

* Catch2 operates with an rng-seed. Knowing what seed a test run had
  is important if you want to replicate it, so your reporter should
  report the rng-seed, if at all possible given the target output format.

* Catch2 also operates with test filters, or test specs. If a filter
  is present, you should also report the filter, if at all possible given
  the target output format.



---

[Home](Readme.md#top)

/* eslint-disable @typescript-eslint/no-unnecessary-type-arguments -- Explicitly testing type arguments that TypeScript could infer, to verify the types are correct */
import type {LookupFunction} from 'node:net';
import {expectTypeOf} from 'expect-type';
import got, {
	Options,
	type OptionsInit,
	type Request,
	type RequestPromise,
	type Response,
} from '../source/index.js';
import {
	type Got,
	type MergeExtendsConfig,
	type ExtractExtendOptions,
	type StrictOptions,
	type ExtendOptions,
} from '../source/types.js';

// Ensure we properly extract the `extend` options from a Got instance which is used in MergeExtendsConfig generic
expectTypeOf<ExtractExtendOptions<Got<{resolveBodyOnly: false}>>>().toEqualTypeOf<{resolveBodyOnly: false}>();
expectTypeOf<ExtractExtendOptions<Got<{resolveBodyOnly: true}>>>().toEqualTypeOf<{resolveBodyOnly: true}>();
expectTypeOf<ExtractExtendOptions<{resolveBodyOnly: false}>>().toEqualTypeOf<{resolveBodyOnly: false}>();
expectTypeOf<ExtractExtendOptions<{resolveBodyOnly: true}>>().toEqualTypeOf<{resolveBodyOnly: true}>();

//
// Tests for MergeExtendsConfig - which merges the potential arguments of the `got.extend` method
//
// MergeExtendsConfig works with a single value
expectTypeOf<MergeExtendsConfig<[{resolveBodyOnly: false}]>>().toEqualTypeOf<{resolveBodyOnly: false}>();
expectTypeOf<MergeExtendsConfig<[{resolveBodyOnly: true}]>>().toEqualTypeOf<{resolveBodyOnly: true}>();
expectTypeOf<MergeExtendsConfig<[Got<{resolveBodyOnly: false}>]>>().toEqualTypeOf<{resolveBodyOnly: false}>();
expectTypeOf<MergeExtendsConfig<[Got<{resolveBodyOnly: true}>]>>().toEqualTypeOf<{resolveBodyOnly: true}>();

// MergeExtendsConfig merges multiple ExtendOptions
expectTypeOf<MergeExtendsConfig<[{resolveBodyOnly: false}, {resolveBodyOnly: true}]>>().toEqualTypeOf<{resolveBodyOnly: true}>();
expectTypeOf<MergeExtendsConfig<[{resolveBodyOnly: true}, {resolveBodyOnly: false}]>>().toEqualTypeOf<{resolveBodyOnly: false}>();

// MergeExtendsConfig merges multiple Got instances
expectTypeOf<MergeExtendsConfig<[Got<{resolveBodyOnly: false}>, Got<{resolveBodyOnly: true}>]>>().toEqualTypeOf<{resolveBodyOnly: true}>();
expectTypeOf<MergeExtendsConfig<[Got<{resolveBodyOnly: true}>, Got<{resolveBodyOnly: false}>]>>().toEqualTypeOf<{resolveBodyOnly: false}>();

// MergeExtendsConfig merges multiple Got instances and ExtendOptions with Got first argument
expectTypeOf<MergeExtendsConfig<[Got<{resolveBodyOnly: false}>, {resolveBodyOnly: true}]>>().toEqualTypeOf<{resolveBodyOnly: true}>();
expectTypeOf<MergeExtendsConfig<[Got<{resolveBodyOnly: true}>, {resolveBodyOnly: false}]>>().toEqualTypeOf<{resolveBodyOnly: false}>();

// MergeExtendsConfig merges multiple Got instances and ExtendOptions with ExtendOptions first argument
expectTypeOf<MergeExtendsConfig<[{resolveBodyOnly: true}, Got<{resolveBodyOnly: false}>]>>().toEqualTypeOf<{resolveBodyOnly: false}>();
expectTypeOf<MergeExtendsConfig<[{resolveBodyOnly: false}, Got<{resolveBodyOnly: true}>]>>().toEqualTypeOf<{resolveBodyOnly: true}>();

//
// Test the implementation of got.extend types
//
expectTypeOf(got.extend({resolveBodyOnly: false})).toEqualTypeOf<Got<{resolveBodyOnly: false}>>();
expectTypeOf(got.extend({resolveBodyOnly: true})).toEqualTypeOf<Got<{resolveBodyOnly: true}>>();
expectTypeOf(got.extend(got.extend({resolveBodyOnly: true}))).toEqualTypeOf<Got<{resolveBodyOnly: true}>>();
expectTypeOf(got.extend(got.extend({resolveBodyOnly: false}))).toEqualTypeOf<Got<{resolveBodyOnly: false}>>();
expectTypeOf(got.extend(got.extend({resolveBodyOnly: true}), {resolveBodyOnly: false})).toEqualTypeOf<Got<{resolveBodyOnly: false}>>();
expectTypeOf(got.extend(got.extend({resolveBodyOnly: false}), {resolveBodyOnly: true})).toEqualTypeOf<Got<{resolveBodyOnly: true}>>();
expectTypeOf(got.extend({resolveBodyOnly: true}, got.extend({resolveBodyOnly: false}))).toEqualTypeOf<Got<{resolveBodyOnly: false}>>();
expectTypeOf(got.extend({resolveBodyOnly: false}, got.extend({resolveBodyOnly: true}))).toEqualTypeOf<Got<{resolveBodyOnly: true}>>();

//
// Test that created instances enable the correct return types for the request functions
//
const gotWrapped = got.extend({});
const queryMethodOptions: OptionsInit = {method: 'query'};
void queryMethodOptions;

// The following tests would apply to all of the method signatures (get, post, put, delete, etc...), but we only test the base function for brevity

// Test the default instance
expectTypeOf(gotWrapped('https://example.com')).toEqualTypeOf<RequestPromise<Response<string>>>();
expectTypeOf(gotWrapped<{test: 'test'}>('https://example.com')).toEqualTypeOf<RequestPromise<Response<{test: 'test'}>>>();
expectTypeOf(gotWrapped('https://example.com', {responseType: 'buffer'})).toEqualTypeOf<RequestPromise<Response<Uint8Array<ArrayBuffer>>>>();
expectTypeOf(gotWrapped.query<{test: 'test'}>('https://example.com')).toEqualTypeOf<RequestPromise<Response<{test: 'test'}>>>();
expectTypeOf(got.stream.query('https://example.com')).toEqualTypeOf<Request>();
expectTypeOf(gotWrapped.stream.query('https://example.com')).toEqualTypeOf<Request>();

// Test the default instance can be overridden at the request function level
expectTypeOf(gotWrapped('https://example.com', {resolveBodyOnly: true})).toEqualTypeOf<RequestPromise<string>>();
expectTypeOf(gotWrapped<{test: 'test'}>('https://example.com', {resolveBodyOnly: true})).toEqualTypeOf<RequestPromise<{test: 'test'}>>();
expectTypeOf(gotWrapped('https://example.com', {responseType: 'buffer', resolveBodyOnly: true})).toEqualTypeOf<RequestPromise<Uint8Array<ArrayBuffer>>>();

const gotBodyOnly = got.extend({resolveBodyOnly: true});

// Test the instance with resolveBodyOnly as an extend option
expectTypeOf(gotBodyOnly('https://example.com')).toEqualTypeOf<RequestPromise<string>>();
expectTypeOf(gotBodyOnly<{test: 'test'}>('https://example.com')).toEqualTypeOf<RequestPromise<{test: 'test'}>>();
expectTypeOf(gotBodyOnly('https://example.com', {responseType: 'buffer'})).toEqualTypeOf<RequestPromise<Uint8Array<ArrayBuffer>>>();

// Test the instance with resolveBodyOnly as an extend option can be overridden at the request function level
expectTypeOf(gotBodyOnly('https://example.com', {resolveBodyOnly: false})).toEqualTypeOf<RequestPromise<Response<string>>>();
expectTypeOf(gotBodyOnly<{test: 'test'}>('https://example.com', {resolveBodyOnly: false})).toEqualTypeOf<RequestPromise<Response<{test: 'test'}>>>();
expectTypeOf(gotBodyOnly('https://example.com', {responseType: 'buffer', resolveBodyOnly: false})).toEqualTypeOf<RequestPromise<Response<Uint8Array<ArrayBuffer>>>>();

//
// Test got.extend() with responseType correctly infers types (fix for issue #2427)
//
const gotJson = got.extend({responseType: 'json'});
const gotJsonBodyOnly = got.extend({responseType: 'json', resolveBodyOnly: true});
const gotBuffer = got.extend({responseType: 'buffer'});
const gotBufferBodyOnly = got.extend({responseType: 'buffer', resolveBodyOnly: true});
const gotText = got.extend({responseType: 'text'});
const gotTextBodyOnly = got.extend({responseType: 'text', resolveBodyOnly: true});

// Test URL-first syntax without options - should infer correct type based on extended responseType
expectTypeOf(gotJson('https://example.com')).toEqualTypeOf<RequestPromise<Response<unknown>>>();
expectTypeOf(gotJsonBodyOnly('https://example.com')).toEqualTypeOf<RequestPromise<unknown>>();
expectTypeOf(gotBuffer('https://example.com')).toEqualTypeOf<RequestPromise<Response<Uint8Array<ArrayBuffer>>>>();
expectTypeOf(gotBufferBodyOnly('https://example.com')).toEqualTypeOf<RequestPromise<Uint8Array<ArrayBuffer>>>();
expectTypeOf(gotText('https://example.com')).toEqualTypeOf<RequestPromise<Response<string>>>();
expectTypeOf(gotTextBodyOnly('https://example.com')).toEqualTypeOf<RequestPromise<string>>();

// @ts-expect-error `url` must be passed as the first argument.
const invalidStrictOptions: StrictOptions = {url: 'https://example.com'};
void invalidStrictOptions;

// Test that generic type parameter still works with extended responseType
expectTypeOf(gotJson<{data: string}>('https://example.com')).toEqualTypeOf<RequestPromise<Response<{data: string}>>>();
expectTypeOf(gotJsonBodyOnly<{data: string}>('https://example.com')).toEqualTypeOf<RequestPromise<{data: string}>>();

// Test that explicit responseType in call overrides extended responseType
expectTypeOf(gotJson('https://example.com', {responseType: 'buffer'})).toEqualTypeOf<RequestPromise<Response<Uint8Array<ArrayBuffer>>>>();
expectTypeOf(gotJson('https://example.com', {responseType: 'text'})).toEqualTypeOf<RequestPromise<Response<string>>>();
expectTypeOf(gotBuffer('https://example.com', {responseType: 'json'})).toEqualTypeOf<RequestPromise<Response<unknown>>>();
expectTypeOf(gotBuffer('https://example.com', {responseType: 'text'})).toEqualTypeOf<RequestPromise<Response<string>>>();

// Test that resolveBodyOnly can be overridden with explicit responseType
expectTypeOf(gotJson('https://example.com', {responseType: 'json', resolveBodyOnly: true})).toEqualTypeOf<RequestPromise<unknown>>();
expectTypeOf(gotJsonBodyOnly('https://example.com', {responseType: 'json', resolveBodyOnly: false})).toEqualTypeOf<RequestPromise<Response<unknown>>>();
expectTypeOf(gotBuffer('https://example.com', {responseType: 'buffer', resolveBodyOnly: true})).toEqualTypeOf<RequestPromise<Uint8Array<ArrayBuffer>>>();
expectTypeOf(gotBufferBodyOnly('https://example.com', {responseType: 'buffer', resolveBodyOnly: false})).toEqualTypeOf<RequestPromise<Response<Uint8Array<ArrayBuffer>>>>();

// @ts-expect-error `url` must not be accepted by extend options.
const invalidExtendOptions: ExtendOptions = {url: 'https://example.com'};
void invalidExtendOptions;

// Test shortcut methods preserve RequestPromise return shape
expectTypeOf(got('https://example.com').json<{data: string}>()).toEqualTypeOf<RequestPromise<{data: string}>>();
expectTypeOf(got('https://example.com').buffer()).toEqualTypeOf<RequestPromise<Uint8Array<ArrayBuffer>>>();
expectTypeOf(got('https://example.com').text()).toEqualTypeOf<RequestPromise<string>>();

const lookup: LookupFunction = () => {};
const clear = () => {};
expectTypeOf(got('https://example.com', {
	dnsCache: {
		lookup,
		clear,
	},
})).toEqualTypeOf<RequestPromise<Response<string>>>();
expectTypeOf(got.extend({
	dnsCache: {
		lookup,
	},
})).toExtend<Got>();
expectTypeOf(got.extend({
	dnsCache: true,
})).toExtend<Got>();
expectTypeOf(got.extend({
	dnsCache: false,
})).toExtend<Got>();
const optionsInit: OptionsInit = {
	dnsCache: true,
};
void optionsInit;

const options = new Options({
	dnsCache: {
		lookup,
	},
});
type NativeRequestOptions = ReturnType<Options['createNativeRequestOptions']>;

expectTypeOf(options.dnsCache).toExtend<{lookup: LookupFunction} | undefined>();
expectTypeOf<NativeRequestOptions['lookup']>().toEqualTypeOf<LookupFunction | undefined>();

'use strict'

var express = require('..')
var request = require('supertest')

describe('req', function(){
  describe('.baseUrl', function(){
    it('should be empty for top-level route', function(done){
      var app = express()

      app.get('/:a', function(req, res){
        res.end(req.baseUrl)
      })

      request(app)
      .get('/foo')
      .expect(200, '', done)
    })

    it('should contain lower path', function(done){
      var app = express()
      var sub = express.Router()

      sub.get('/:b', function(req, res){
        res.end(req.baseUrl)
      })
      app.use('/:a', sub)

      request(app)
      .get('/foo/bar')
      .expect(200, '/foo', done);
    })

    it('should contain full lower path', function(done){
      var app = express()
      var sub1 = express.Router()
      var sub2 = express.Router()
      var sub3 = express.Router()

      sub3.get('/:d', function(req, res){
        res.end(req.baseUrl)
      })
      sub2.use('/:c', sub3)
      sub1.use('/:b', sub2)
      app.use('/:a', sub1)

      request(app)
      .get('/foo/bar/baz/zed')
      .expect(200, '/foo/bar/baz', done);
    })

    it('should travel through routers correctly', function(done){
      var urls = []
      var app = express()
      var sub1 = express.Router()
      var sub2 = express.Router()
      var sub3 = express.Router()

      sub3.get('/:d', function(req, res, next){
        urls.push('0@' + req.baseUrl)
        next()
      })
      sub2.use('/:c', sub3)
      sub1.use('/', function(req, res, next){
        urls.push('1@' + req.baseUrl)
        next()
      })
      sub1.use('/bar', sub2)
      sub1.use('/bar', function(req, res, next){
        urls.push('2@' + req.baseUrl)
        next()
      })
      app.use(function(req, res, next){
        urls.push('3@' + req.baseUrl)
        next()
      })
      app.use('/:a', sub1)
      app.use(function(req, res, next){
        urls.push('4@' + req.baseUrl)
        res.end(urls.join(','))
      })

      request(app)
      .get('/foo/bar/baz/zed')
      .expect(200, '3@,1@/foo,0@/foo/bar/baz,2@/foo/bar,4@', done);
    })
  })
})

import test from 'ava';
import * as toughCookie from 'tough-cookie';
import delay from 'delay';
import got, {RequestError} from '../source/index.js';
import {createRawHttpServer} from './helpers/server-tools.js';
import withServer from './helpers/with-server.js';

test('reads a cookie', withServer, async (t, server, got) => {
	server.get('/', (_request, response) => {
		response.setHeader('set-cookie', 'hello=world');
		response.end();
	});

	const cookieJar = new toughCookie.CookieJar();

	await got({cookieJar});

	const cookie = cookieJar.getCookiesSync(server.url)[0];
	t.is(cookie?.key, 'hello');
	t.is(cookie?.value, 'world');
});

test('reads multiple cookies', withServer, async (t, server, got) => {
	server.get('/', (_request, response) => {
		response.setHeader('set-cookie', ['hello=world', 'foo=bar']);
		response.end();
	});

	const cookieJar = new toughCookie.CookieJar();

	await got({cookieJar});

	const [cookieA, cookieB] = cookieJar.getCookiesSync(server.url);
	t.is(cookieA!.key, 'hello');
	t.is(cookieA!.value, 'world');
	t.is(cookieB!.key, 'foo');
	t.is(cookieB!.value, 'bar');
});

test('cookies doesn\'t break on redirects', withServer, async (t, server, got) => {
	server.get('/redirect', (_request, response) => {
		response.setHeader('set-cookie', ['hello=world', 'foo=bar']);
		response.setHeader('location', '/');
		response.statusCode = 302;
		response.end();
	});

	server.get('/', (request, response) => {
		response.end(request.headers.cookie ?? '');
	});

	const cookieJar = new toughCookie.CookieJar();

	const {body} = await got('redirect', {cookieJar});
	t.is(body, 'hello=world; foo=bar');
});

test('throws on invalid cookies', withServer, async (t, server, got) => {
	server.get('/', (_request, response) => {
		response.setHeader('set-cookie', 'invalid cookie; domain=localhost');
		response.end();
	});

	const cookieJar = new toughCookie.CookieJar();

	await t.throwsAsync(got({cookieJar}), {
		instanceOf: RequestError,
		message: 'Cookie failed to parse',
	});
});

test('does not throw on invalid cookies when options.ignoreInvalidCookies is set', withServer, async (t, server, got) => {
	server.get('/', (_request, response) => {
		response.setHeader('set-cookie', 'invalid cookie; domain=localhost');
		response.end();
	});

	const cookieJar = new toughCookie.CookieJar();

	await got({
		cookieJar,
		ignoreInvalidCookies: true,
	});

	const cookies = cookieJar.getCookiesSync(server.url);
	t.is(cookies.length, 0);
});

test('catches store errors', async t => {
	const error = 'Some error';
	const cookieJar = new toughCookie.CookieJar({
		findCookies(_domain: any, _path: any, _allowSpecialUseDomain: any, callback: any) {
			callback(new Error(error), []);
		},
		findCookie() {},
		getAllCookies() {},
		putCookie() {},
		removeCookies() {},
		removeCookie() {},
		updateCookie() {},
		synchronous: false,
	} as any);

	await t.throwsAsync(got('https://example.com', {cookieJar}), {
		instanceOf: RequestError,
		message: error,
	});
});

test('overrides options.headers.cookie', withServer, async (t, server, got) => {
	server.get('/redirect', (_request, response) => {
		response.setHeader('set-cookie', ['hello=world', 'foo=bar']);
		response.setHeader('location', '/');
		response.statusCode = 302;
		response.end();
	});

	server.get('/', (request, response) => {
		response.end(request.headers.cookie ?? '');
	});

	const cookieJar = new toughCookie.CookieJar();
	const {body} = await got('redirect', {
		cookieJar,
		headers: {
			cookie: 'a=b',
		},
	});
	t.is(body, 'hello=world; foo=bar');
});

test('no unhandled errors', async t => {
	const {port, close} = await createRawHttpServer(connection => {
		connection.end('blah');
	});

	const message = 'snap!';

	const options = {
		cookieJar: {
			async setCookie(_rawCookie: string, _url: string) {},
			async getCookieString(_url: string) {
				throw new Error(message);
			},
		},
	};

	await t.throwsAsync(got(`http://127.0.0.1:${port}`, options), {
		instanceOf: RequestError,
		message,
	});
	await delay(500);

	await close();
});

test('accepts custom `cookieJar` object', withServer, async (t, server, got) => {
	server.get('/', (request, response) => {
		response.setHeader('set-cookie', ['hello=world']);
		response.end(request.headers.cookie);
	});

	const cookies: Record<string, string> = {};
	const cookieJar = {
		async getCookieString(url: string) {
			t.is(typeof url, 'string');
			return cookies[url] ?? '';
		},

		async setCookie(rawCookie: string, url: string) {
			cookies[url] = rawCookie;
		},
	};

	const first = await got('', {cookieJar});
	const second = await got('', {cookieJar});

	t.is(first.body, '');
	t.is(second.body, 'hello=world');
});

test('throws on invalid `options.cookieJar.setCookie`', async t => {
	await t.throwsAsync(got('https://example.com', {
		cookieJar: {
			// @ts-expect-error Error tests
			setCookie: 123,
		},
	}), {
		instanceOf: RequestError,
		message: 'Expected value which is `Function`, received value of type `number`.',
	});
});

test('throws on invalid `options.cookieJar.getCookieString`', async t => {
	await t.throwsAsync(got('https://example.com', {
		cookieJar: {
			async setCookie() {},
			// @ts-expect-error Error tests
			getCookieString: 123,
		},
	}), {
		instanceOf: RequestError,
		message: 'Expected value which is `Function`, received value of type `number`.',
	});
});

test('cookies are cleared when redirecting to a different hostname (no cookieJar)', withServer, async (t, server1, got) => {
	await withServer.exec(t, async (t, server2) => {
		server1.get('/', (_request, response) => {
			response.writeHead(302, {
				location: `http://localhost:${server2.port}/`,
			});
			response.end();
		});

		server2.get('/', (request, response) => {
			response.end(JSON.stringify({headers: request.headers}));
		});

		const {headers} = await got('', {
			headers: {
				cookie: 'foo=bar',
				'user-agent': 'custom',
			},
		}).json<{headers: Record<string, string | undefined>}>();
		t.is(headers.cookie, undefined);
		t.is(headers['user-agent'], 'custom');
	});
});

import click


def test_prompts(runner):
    @click.command()
    def test():
        if click.confirm("Foo"):
            click.echo("yes!")
        else:
            click.echo("no :(")

    result = runner.invoke(test, input="y\n")
    assert not result.exception
    assert result.output == "Foo [y/N]: y\nyes!\n"

    result = runner.invoke(test, input="\n")
    assert not result.exception
    assert result.output == "Foo [y/N]: \nno :(\n"

    result = runner.invoke(test, input="n\n")
    assert not result.exception
    assert result.output == "Foo [y/N]: n\nno :(\n"

    @click.command()
    def test_no():
        if click.confirm("Foo", default=True):
            click.echo("yes!")
        else:
            click.echo("no :(")

    result = runner.invoke(test_no, input="y\n")
    assert not result.exception
    assert result.output == "Foo [Y/n]: y\nyes!\n"

    result = runner.invoke(test_no, input="\n")
    assert not result.exception
    assert result.output == "Foo [Y/n]: \nyes!\n"

    result = runner.invoke(test_no, input="n\n")
    assert not result.exception
    assert result.output == "Foo [Y/n]: n\nno :(\n"


def test_confirm_repeat(runner):
    cli = click.Command(
        "cli", params=[click.Option(["--a/--no-a"], default=None, prompt=True)]
    )
    result = runner.invoke(cli, input="\ny\n")
    assert result.output == "A [y/n]: \nError: invalid input\nA [y/n]: y\n"

{
	"extends": "@sindresorhus/tsconfig",
	"compilerOptions": {
		"outDir": "dist",
		"target": "es2024", // Node.js 22
		"lib": [
			"es2024",
			"esnext.array"
		],
		"noPropertyAccessFromIndexSignature": false,
		"isolatedModules": true
	},
	"include": [
		"source",
		"test",
		"benchmark"
	]
}

import type http from 'node:http';
import https from 'node:https';
import type net from 'node:net';
import type {SecureContextOptions} from 'node:tls';
import express from 'express';
import pify from 'pify';
import pem from 'pem';
import type {CreateCsr, CreateCertificate} from '../types/pem.js';

export type HttpsServerOptions = {
	commonName?: string;
	days?: number;
	ciphers?: SecureContextOptions['ciphers'];
	honorCipherOrder?: SecureContextOptions['honorCipherOrder'];
	minVersion?: SecureContextOptions['minVersion'];
	maxVersion?: SecureContextOptions['maxVersion'];
};

export type ExtendedHttpsTestServer = {
	https: https.Server;
	caKey: Uint8Array;
	caCert: Uint8Array;
	url: string;
	port: number;
	close: () => Promise<void>;
} & express.Express;

const createHttpsTestServer = async (options: HttpsServerOptions = {}): Promise<ExtendedHttpsTestServer> => {
	const createCsr = pify(pem.createCSR as CreateCsr);
	const createCertificate = pify(pem.createCertificate as CreateCertificate);
	const commonName = options.commonName ?? 'localhost';
	const serverCertificateConfiguration = `
[req]
req_extensions = v3_req
[dn]
CN = ${commonName}
[v3_req]
basicConstraints = critical,CA:FALSE
keyUsage = critical,digitalSignature,keyEncipherment
extendedKeyUsage = serverAuth
subjectAltName = @alt_names
[alt_names]
DNS.1 = ${commonName}
`;
	const caCertificateConfiguration = `
[req]
req_extensions = v3_req
[dn]
CN = authority
[v3_req]
basicConstraints = critical,CA:TRUE
keyUsage = critical,keyCertSign,cRLSign
`;

	const caCsrResult = await createCsr({commonName: 'authority'});
	const caResult = await createCertificate({
		csr: caCsrResult.csr,
		clientKey: caCsrResult.clientKey,
		selfSigned: true,
		config: caCertificateConfiguration,
	});
	const caKey = caResult.clientKey;
	const caCert = caResult.certificate;

	const serverCsrResult = await createCsr({commonName});
	const serverResult = await createCertificate({
		csr: serverCsrResult.csr,
		clientKey: serverCsrResult.clientKey,
		serviceKey: caKey,
		serviceCertificate: caCert,
		config: serverCertificateConfiguration,
		days: options.days ?? 365,
	});
	const serverKey = serverResult.clientKey;
	const serverCert = serverResult.certificate;

	const server = express() as ExtendedHttpsTestServer;
	server.https = https.createServer(
		{
			key: serverKey,
			cert: serverCert,
			ca: caCert,
			requestCert: true,
			rejectUnauthorized: false, // This should be checked by the test
			ciphers: options.ciphers,
			honorCipherOrder: options.honorCipherOrder,
			minVersion: options.minVersion,
			maxVersion: options.maxVersion,
		},
		server as unknown as http.RequestListener,
	);

	server.set('etag', false);

	await pify(server.https.listen.bind(server.https))();

	server.caKey = caKey as any;
	server.caCert = caCert;
	server.port = (server.https.address() as net.AddressInfo).port;
	server.url = `https://localhost:${server.port}`;

	server.close = async () => new Promise<void>((resolve, reject) => {
		server.https.closeAllConnections?.();
		server.https.close(error => {
			if (error) {
				reject(error);
				return;
			}

			resolve();
		});
	});

	return server;
};

export default createHttpsTestServer;

import process from 'node:process';
import type {IncomingMessage, ServerResponse} from 'node:http';
import {format} from 'node:util';
import test from 'ava';
import getStream from 'get-stream';
import baseGot, {Options, RequestError} from '../source/index.js';
import {withSocketServer} from './helpers/with-server.js';
import type {ExtendedHttpServer} from './helpers/types.js';

const got = baseGot.extend({enableUnixSockets: true});

const okHandler = (_request: IncomingMessage, response: ServerResponse): void => {
	response.end('ok');
};

const redirectHandler = (_request: IncomingMessage, response: ServerResponse): void => {
	response.writeHead(302, {
		location: 'foo',
	});
	response.end();
};

function socketUrl(socketPath: string, path = '/'): string {
	return format('http://unix:%s:%s', socketPath, path);
}

function attachRetryUrlResponse(server: ExtendedHttpServer, socketPath: string, path = '/target'): void {
	server.on('/', (_request, response) => {
		response.setHeader('content-type', 'application/json');
		response.end(JSON.stringify({
			retryUrl: socketUrl(socketPath, path),
		}));
	});
}

function readRetryUrl(responseBody: string): URL {
	return new URL(JSON.parse(responseBody).retryUrl);
}

function withDisabledHttpAgent(): {agent: {http: false}} {
	return {
		agent: {
			http: false,
		},
	};
}

function captureRequest(server: ExtendedHttpServer, path: string, responseBody: string): {body: () => string; contentType: () => string | undefined} {
	let requestBody = '';
	let contentType: string | undefined;

	server.on(path, (request, response) => {
		void (async () => {
			requestBody = await getStream(request);
			contentType = request.headers['content-type'];
			response.end(responseBody);
		})();
	});

	return {
		body: () => requestBody,
		contentType: () => contentType,
	};
}

if (process.platform !== 'win32') {
	test('works', withSocketServer, async (t, server) => {
		void server.on('/', okHandler);

		const url = socketUrl(server.socketPath);
		t.is((await got(url, {})).body, 'ok');
	});

	test('protocol-less works', withSocketServer, async (t, server) => {
		void server.on('/', okHandler);

		const url = format('unix:%s:%s', server.socketPath, '/');
		t.is((await got(url)).body, 'ok');
	});

	test('address with : works', withSocketServer, async (t, server) => {
		void server.on('/foo:bar', okHandler);

		const url = format('unix:%s:%s', server.socketPath, '/foo:bar');
		t.is((await got(url)).body, 'ok');
	});

	test('throws on invalid URL', async t => {
		const error = await t.throwsAsync<RequestError>(got('unix:', {retry: {limit: 0}}));
		t.regex(error?.code ?? '', /ENOTFOUND|EAI_AGAIN/v);
	});

	test('works when extending instances', withSocketServer, async (t, server) => {
		void server.on('/', okHandler);

		const url = format('unix:%s:%s', server.socketPath, '/');
		const instance = got.extend({prefixUrl: url});
		t.is((await instance('')).body, 'ok');
	});

	test('passes search params', withSocketServer, async (t, server) => {
		void server.on('/?a=1', okHandler);

		const url = socketUrl(server.socketPath, '/?a=1');
		t.is((await got(url)).body, 'ok');
	});

	test('redirects work', withSocketServer, async (t, server) => {
		void server.on('/', redirectHandler);
		void server.on('/foo', okHandler);

		const url = socketUrl(server.socketPath);
		t.is((await got(url)).body, 'ok');
	});

	test('redirects to a different UNIX socket fail', withSocketServer, async (t, firstServer) => {
		await withSocketServer.exec(t, async (t, secondServer) => {
			firstServer.on('/', (_request, response) => {
				response.writeHead(302, {
					location: format('unix:%s:%s', secondServer.socketPath, '/foo'),
				});
				response.end();
			});

			void secondServer.on('/foo', okHandler);

			const url = socketUrl(firstServer.socketPath);
			await t.throwsAsync(got(url), {
				message: 'Cannot redirect to UNIX socket',
				instanceOf: RequestError,
			});
		});
	});

	test('`unix:` fails when UNIX sockets are not enabled', async t => {
		const gotUnixSocketsDisabled = got.extend({enableUnixSockets: false});

		t.false(gotUnixSocketsDisabled.defaults.options.enableUnixSockets);
		await t.throwsAsync(
			gotUnixSocketsDisabled('unix:'),
			{
				message: 'Using UNIX domain sockets but option `enableUnixSockets` is not enabled',
			},
		);
	});

	test('`http://unix/path.sock:/` fails when UNIX sockets are not enabled', async t => {
		const gotUnixSocketsDisabled = got.extend({enableUnixSockets: false});

		t.false(gotUnixSocketsDisabled.defaults.options.enableUnixSockets);

		await t.throwsAsync(
			gotUnixSocketsDisabled('http://unix/tmp/test.sock:/'),
			{
				message: 'Using UNIX domain sockets but option `enableUnixSockets` is not enabled',
			},
		);
	});

	test('mutating the URL to a UNIX socket in place still requires opt-in', t => {
		const options = new Options('http://example.com');
		(options.url as URL).href = 'http://unix:/tmp/test.sock:/';

		t.throws(() => {
			options.createNativeRequestOptions();
		}, {
			message: 'Using UNIX domain sockets but option `enableUnixSockets` is not enabled',
		});
	});

	test('allowAbsoluteUrls false rejects in-place mutation to a different UNIX socket', withSocketServer, async (t, firstServer) => {
		await withSocketServer.exec(t, async (t, secondServer) => {
			void firstServer.on('/', okHandler);

			const client = got.extend({
				allowAbsoluteUrls: false,
				prefixUrl: socketUrl(firstServer.socketPath),
			});

			await t.throwsAsync(client('', {
				hooks: {
					beforeRequest: [
						options => {
							options.url!.pathname = `${secondServer.socketPath}:/`;
						},
					],
				},
			}), {
				instanceOf: RequestError,
				message: 'The `url` option must stay on the same origin as `prefixUrl` when `allowAbsoluteUrls` is false',
			});
		});
	});

	test('allowAbsoluteUrls false rejects retryWithMergedOptions string URL to a different UNIX socket', withSocketServer, async (t, firstServer) => {
		await withSocketServer.exec(t, async (t, secondServer) => {
			firstServer.on('/', (_request, response) => {
				response.end('first');
			});

			void secondServer.on('/target', okHandler);

			const client = got.extend({
				allowAbsoluteUrls: false,
				prefixUrl: socketUrl(firstServer.socketPath),
			});

			await t.throwsAsync(client('', {
				hooks: {
					afterResponse: [
						(_response, retryWithMergedOptions) => retryWithMergedOptions({
							url: format('unix:%s:%s', secondServer.socketPath, '/target'),
						}),
					],
				},
			}), {
				instanceOf: RequestError,
				message: 'The `url` option must be relative when `allowAbsoluteUrls` is false and `prefixUrl` is set',
			});
		});
	});

	test('allowAbsoluteUrls false rejects retryWithMergedOptions backslash URL to a different UNIX socket', withSocketServer, async (t, firstServer) => {
		await withSocketServer.exec(t, async (t, secondServer) => {
			firstServer.on('/', (_request, response) => {
				response.end('first');
			});

			void secondServer.on('/target', okHandler);

			const client = got.extend({
				allowAbsoluteUrls: false,
				prefixUrl: socketUrl(firstServer.socketPath),
			});

			await t.throwsAsync(client('', {
				hooks: {
					afterResponse: [
						(_response, retryWithMergedOptions) => retryWithMergedOptions({
							url: format(String.raw`\\unix:%s:%s`, secondServer.socketPath, '/target'),
						}),
					],
				},
			}), {
				instanceOf: RequestError,
				message: 'The `url` option must be relative when `allowAbsoluteUrls` is false and `prefixUrl` is set',
			});
		});
	});

	test('retryWithMergedOptions strips sensitive headers when moving to a different UNIX socket', withSocketServer, async (t, firstServer) => {
		await withSocketServer.exec(t, async (t, secondServer) => {
			attachRetryUrlResponse(firstServer, secondServer.socketPath);

			secondServer.on('/target', (request, response) => {
				response.end(JSON.stringify({
					authorization: request.headers.authorization,
					cookie: request.headers.cookie,
				}));
			});

			const url = socketUrl(firstServer.socketPath);
			const result = await got(url, {
				headers: {
					authorization: 'Bearer secret',
					cookie: 'session=abc',
				},
				hooks: {
					afterResponse: [
						(response, retryWithMergedOptions) => retryWithMergedOptions({
							url: readRetryUrl(response.body as string),
						}),
					],
				},
			}).json<{authorization: string | undefined; cookie: string | undefined}>();

			t.is(result.authorization, undefined);
			t.is(result.cookie, undefined);
		});
	});

	test('pagination strips sensitive headers when moving to a different UNIX socket', withSocketServer, async (t, firstServer) => {
		await withSocketServer.exec(t, async (t, secondServer) => {
			let authorization: string | undefined;
			let cookie: string | undefined;
			firstServer.on('/', (_request, response) => {
				response.end('[1]');
			});

			secondServer.on('/target', (request, response) => {
				authorization = request.headers.authorization;
				cookie = request.headers.cookie;
				response.end('[]');
			});

			const url = socketUrl(firstServer.socketPath);
			const result = await got.paginate.all<number>(url, {
				headers: {
					authorization: 'Bearer secret',
					cookie: 'session=abc',
				},
				pagination: {
					requestLimit: 2,
					paginate({response}) {
						if (response.body === '[1]') {
							return {
								url: new URL(socketUrl(secondServer.socketPath, '/target')),
							};
						}

						return false;
					},
				},
			});

			t.deepEqual(result, [1]);
			t.is(authorization, undefined);
			t.is(cookie, undefined);
		});
	});

	test('retryWithMergedOptions drops body when moving to a different UNIX socket', withSocketServer, async (t, firstServer) => {
		await withSocketServer.exec(t, async (t, secondServer) => {
			attachRetryUrlResponse(firstServer, secondServer.socketPath);
			const capturedRequest = captureRequest(secondServer, '/target', 'ok');
			const url = socketUrl(firstServer.socketPath);
			await got.post(url, {
				...withDisabledHttpAgent(),
				json: {secret: 'payload'},
				hooks: {
					afterResponse: [
						(response, retryWithMergedOptions) => retryWithMergedOptions({
							url: readRetryUrl(response.body as string),
						}),
					],
				},
			});

			t.is(capturedRequest.body(), '');
			t.is(capturedRequest.contentType(), undefined);
		});
	});

	test('pagination drops body when moving to a different UNIX socket', withSocketServer, async (t, firstServer) => {
		await withSocketServer.exec(t, async (t, secondServer) => {
			firstServer.on('/', (_request, response) => {
				response.end('[1]');
			});

			const capturedRequest = captureRequest(secondServer, '/target', '[]');
			const url = socketUrl(firstServer.socketPath);
			const result = await got.paginate.all<number>(url, {
				...withDisabledHttpAgent(),
				method: 'POST',
				json: {secret: 'payload'},
				pagination: {
					requestLimit: 2,
					paginate({response}) {
						if (response.body === '[1]') {
							return {
								url: new URL(socketUrl(secondServer.socketPath, '/target')),
							};
						}

						return false;
					},
				},
			});

			t.deepEqual(result, [1]);
			t.is(capturedRequest.body(), '');
			t.is(capturedRequest.contentType(), undefined);
		});
	});

	test('retryWithMergedOptions preserves explicit replacement body when moving to a different UNIX socket', withSocketServer, async (t, firstServer) => {
		await withSocketServer.exec(t, async (t, secondServer) => {
			attachRetryUrlResponse(firstServer, secondServer.socketPath);
			const capturedRequest = captureRequest(secondServer, '/target', 'ok');
			const url = socketUrl(firstServer.socketPath);
			await got.post(url, {
				...withDisabledHttpAgent(),
				json: {secret: 'old-payload'},
				hooks: {
					afterResponse: [
						(response, retryWithMergedOptions) => retryWithMergedOptions({
							url: readRetryUrl(response.body as string),
							json: {secret: 'new-payload'},
						}),
					],
				},
			});

			t.is(JSON.parse(capturedRequest.body()).secret, 'new-payload');
			t.is(capturedRequest.contentType(), 'application/json');
		});
	});

	test('pagination preserves explicit replacement body when moving to a different UNIX socket', withSocketServer, async (t, firstServer) => {
		await withSocketServer.exec(t, async (t, secondServer) => {
			firstServer.on('/', (_request, response) => {
				response.end('[1]');
			});

			const capturedRequest = captureRequest(secondServer, '/target', '[2]');
			const url = socketUrl(firstServer.socketPath);
			const result = await got.paginate.all<number>(url, {
				...withDisabledHttpAgent(),
				method: 'POST',
				json: {secret: 'old-payload'},
				pagination: {
					requestLimit: 2,
					paginate({response}) {
						if (response.body === '[1]') {
							return {
								url: new URL(socketUrl(secondServer.socketPath, '/target')),
								json: {secret: 'new-payload'},
							};
						}

						return false;
					},
				},
			});

			t.deepEqual(result, [1, 2]);
			t.is(JSON.parse(capturedRequest.body()).secret, 'new-payload');
			t.is(capturedRequest.contentType(), 'application/json');
		});
	});

	test('retryWithMergedOptions preserves body and headers on the same UNIX socket', withSocketServer, async (t, server) => {
		let requestNumber = 0;
		let secondAuthorization: string | undefined;
		server.on('/', (request, response) => {
			void (async () => {
				requestNumber++;
				const body = await getStream(request);

				if (requestNumber === 1) {
					response.setHeader('content-type', 'application/json');
					response.end(JSON.stringify({
						retryUrl: format('http://unix:%s:%s', server.socketPath, '/'),
					}));
					return;
				}

				secondAuthorization = request.headers.authorization;
				response.end(body);
			})();
		});

		const url = socketUrl(server.socketPath);
		const response = await got.post(url, {
			...withDisabledHttpAgent(),
			headers: {
				authorization: 'Bearer secret',
			},
			json: {secret: 'payload'},
			hooks: {
				afterResponse: [
					(response, retryWithMergedOptions) => retryWithMergedOptions({
						url: readRetryUrl(response.body as string),
					}),
				],
			},
		});

		t.is(JSON.parse(response.body).secret, 'payload');
		t.is(secondAuthorization, 'Bearer secret');
	});

	test('pagination preserves body on the same UNIX socket', withSocketServer, async (t, server) => {
		const payloads: string[] = [];
		const handler = (request: IncomingMessage, response: ServerResponse): void => {
			void (async () => {
				payloads.push(await getStream(request));
				response.end(JSON.stringify([payloads.length]));
			})();
		};

		server.on('/', handler);
		server.on('/?page=2', handler);

		const url = socketUrl(server.socketPath);
		const result = await got.paginate.all<number>(url, {
			...withDisabledHttpAgent(),
			method: 'POST',
			json: {secret: 'payload'},
			pagination: {
				requestLimit: 2,
				paginate({response}) {
					if (response.body === '[1]') {
						return {
							url: new URL(socketUrl(server.socketPath, '/?page=2')),
						};
					}

					return false;
				},
			},
		});

		t.deepEqual(result, [1, 2]);
		t.deepEqual(payloads.map(payload => JSON.parse(payload).secret), ['payload', 'payload']);
	});
}