organicmaps/icu
13
Fork 0
mirror of https://github.com/unicode-org/icu.git synced 2025-04-06 05:55:35 +00:00
Code Issues1 Projects Releases Wiki Activity Actions11

ICU-22847 Migrate ADO pipelines to GHA

Browse source 
See 
    - Update Docs
    - Make exhaustive tests run manually, based on cron for main and post merge for maint
This commit is contained in:
Rahul Pandey 2024-09-05 09:25:05 +00:00
parent 46712bff3d
commit 91ed39fb9d
18 changed files with 516 additions and 195 deletions

81
.ci-builds/.azure-exhaustive-tests.yml
View file

@ -1,81 +0,0 @@
# Azure Pipelines configuration for Exhaustive Tests for ICU.
#
# Note: The exhaustive test configuration is in a separate file
# so that it can be run independently from the regular builds.
#
# Only run the exhaustive tests on the main and maint branches, and
# also batch up any pending changes so that we will only have at most
# one build running at a given time (since they take a long time).
trigger:
# batch=true to reduce number of concurrent runs on the same branch:
# https://learn.microsoft.com/en-us/azure/devops/pipelines/yaml-schema/trigger?view=azure-pipelines#properties
# potential future feature to supersede batch=true:
# https://learn.microsoft.com/en-us/azure/devops/pipelines/process/stages?view=azure-devops&tabs=yaml#specify-queuing-policies
batch: true
branches:
include:
- main
- maint/maint-*
paths:
include:
- '*'
exclude:
- .github/*
- .ci-builds/.azure-pipelines-icu4c.yml
- .ci-builds/.azure-pipelines-icu4j.yml
- .ci-builds/.azure-valgrind.yml
- docs/*
- tools/*
- vendor/*
- .cpyskip.txt
- .travis.yml
- KEYS
- README.md
variables:
MAVEN_ARGS: '--show-version --no-transfer-progress'
jobs:
#-------------------------------------------------------------------------
# Note: The exhaustive tests can take more than 1 hour to complete.
- job: ICU4J_OpenJDK_Ubuntu_2204
displayName: 'J: Linux OpenJDK (Ubuntu 22.04)'
timeoutInMinutes: 180
pool:
vmImage: 'ubuntu-22.04'
demands: ant
steps:
- checkout: self
lfs: true
fetchDepth: 10
- script: |
echo "Building ICU4J" && cd icu4j && mvn install -DICU.exhaustive=10
displayName: 'Build and Exhaustive Tests'
env:
BUILD: ICU4J
- script: |
cd icu4j && cat `find . -name surefire-reports -type d -exec grep -l -r --include="*.txt" FAILED {} \;`
condition: failed() # only run if the build fails.
displayName: 'List failures (if any)'
timeoutInMinutes: 2
#-------------------------------------------------------------------------
# Note: The exhaustive tests can take more than 1 hour to complete.
- job: ICU4C_Clang_Exhaustive_Ubuntu_2204
displayName: 'C: Linux Clang Exhaustive Tests (Ubuntu 22.04)'
timeoutInMinutes: 120
pool:
vmImage: 'ubuntu-22.04'
steps:
- checkout: self
lfs: true
fetchDepth: 10
- script: |
cd icu4c/source && ./runConfigureICU Linux && make -j -l2.5
displayName: 'Build'
- script: |
cd icu4c/source && make check-exhaustive
displayName: 'Exhaustive Tests'
env:
CC: clang
CXX: clang++
#-------------------------------------------------------------------------

6
.ci-builds/.azure-pipelines-icu4c.yml
View file

@ -67,7 +67,7 @@ jobs:
# calling makeconv for it, although the Makefile has appropriate dependencies.
- script: |
cd icu4c/source && \
ICU_DATA_FILTER_FILE=../../.ci-builds/data-filter.json ./runConfigureICU Linux && \
ICU_DATA_FILTER_FILE=../../.github/data-filter.json ./runConfigureICU Linux && \
make -j2 tests && \
\[ ! -d data/out/build/icudt66l/translit \] && \
(cd test/intltest && LD_LIBRARY_PATH=../../lib:../../tools/ctestfw ./intltest translit/TransliteratorTest/TestBasicTransliteratorEvenWithoutData) && \
@ -272,7 +272,7 @@ jobs:
- Cmd
steps:
- powershell: |
$filterPath = $Env:BUILD_SOURCESDIRECTORY + "\.ci-builds\data-filter.json"
$filterPath = $Env:BUILD_SOURCESDIRECTORY + "\.github\data-filter.json"
$vstsCommandString = "vso[task.setvariable variable=ICU_DATA_FILTER_FILE]" + $filterPath
Write-Host "##$vstsCommandString"
- task: VSBuild@1
@ -667,4 +667,4 @@ jobs:
displayName: 'Run Tests (icucheck.bat)'
inputs:
filename: icu4c/source/allinone/icucheck.bat
arguments: 'x64 Release'
arguments: 'x64 Release'

0
.ci-builds/data-filter.json → .github/data-filter.json vendored
View file

325
.github/workflows/icu4c.yml vendored
View file

@ -75,6 +75,26 @@ jobs:
make install;
PATH=$PREFIX/bin:$PATH make -C test/hdrtst check
#gcc 11 with c++ 20
gcc11-cpp20:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
- name: Install GCC-11
run: |
sudo add-apt-repository ppa:ubuntu-toolchain-r/test
sudo apt update
sudo apt install gcc-11 g++-11
- name: Build and Test
env:
CC: gcc-11
CXX: g++-11
CXXFLAGS: -std=c++20 -fext-numeric-literals
run: |
cd icu4c/source;
./runConfigureICU Linux
make -j -l4.5 check;
# clang release build with some options to enforce useful constraints.
# Includes dependency checker on an in-source, optimized build.
# Includes checking @draft etc. API tags vs. ifndef guards like
@ -106,6 +126,12 @@ jobs:
run: |
cd icu4c;
source/test/hdrtst/testtagsguards.sh;
- name: Test C Default locale
run: |
cd icu4c/source/test/cintltst && LANG=C LD_LIBRARY_PATH=../../lib:../../tools/ctestfw ./cintltst /tsutil/cloctst/TestCDefaultLocale
- name: Test C.UTF-8 Default locale
run: |
cd icu4c/source/test/cintltst && LANG=C.UTF-8 LD_LIBRARY_PATH=../../lib:../../tools/ctestfw ./cintltst /tsutil/cloctst/TestCDefaultLocale
- name: Make Dist
env:
CPPFLAGS: -DU_NO_DEFAULT_INCLUDE_UTF_HEADERS=1
@ -240,6 +266,81 @@ jobs:
CPPFLAGS: -fsanitize=thread
LDFLAGS: -fsanitize=thread
#------------------------------------------------------
# Clang Linux with data filter
# Note: This job uses `make -j2` instead of `make -j -l4.5` because with more parallelism (PR #2456)
# this check became flaky. The build apparently was not done copying one or another .ucm file before
# calling makeconv for it, although the Makefile has appropriate dependencies.
clang-datafilter:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
- name: Extract ICU version
run: |
# Extract ICU version from icuver.txt
icuverContent=$(cat icu4c/source/data/misc/icuver.txt)
icuVersion=$(echo "$icuverContent" | grep -oP 'ICUVersion\{"\K\d+\.\d+\.\d+\.\d+')
majorVersion=$(echo "$icuVersion" | cut -d. -f1)
echo "majorVersion=$majorVersion"
echo "majorVersion=$majorVersion" >> $GITHUB_ENV
- name: Build ICU4C with clang
run: |
cd icu4c/source && \
ICU_DATA_FILTER_FILE=../../.github/data-filter.json ./runConfigureICU Linux/clang && \
make -j2 tests && \
\[ ! -d data/out/build/icudt${majorVersion}l/translit \] && \
(cd test/intltest && LD_LIBRARY_PATH=../../lib:../../tools/ctestfw ./intltest translit/TransliteratorTest/TestBasicTransliteratorEvenWithoutData) && \
(cd test/cintltst && LANG=C LD_LIBRARY_PATH=../../lib:../../tools/ctestfw ./cintltst /tsutil/cloctst/TestEnglishExemplarCharacters /tsutil/cldrtest/TestCoverage)
# Clang Linux with CPP 17
clang-cpp17:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
- name: Build ICU4C with CPP 17
env:
CXXFLAGS: -std=c++17 -Winvalid-constexpr
run: |
cd icu4c/source && ./runConfigureICU --enable-debug --disable-release Linux/clang && make -j -l4.5 check
# Clang Linux with LANG: en_US@calendar=gregorian;hours=h12
clang-lang-with-extn-tags:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
- name: Linux Clang - LANG has extension tags
env:
LANG: "en_US@calendar=gregorian;hours=h12"
run: |
cd icu4c/source && ./runConfigureICU --enable-debug --disable-release Linux/clang && make -j -l4.5 check
# Clang Linux 16 with CPP20 and treat warnings as errors
clang16-cpp20-warning-as-errors:
runs-on: ubuntu-latest
strategy:
fail-fast: false
matrix:
flags:
- '-std=c++20'
- '-std=c++20 -stdlib=libc++'
steps:
- uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
- name: Install Clang-16
run: |
curl -Ls https://apt.llvm.org/llvm-snapshot.gpg.key | sudo apt-key add -
sudo apt-add-repository 'deb http://apt.llvm.org/focal/ llvm-toolchain-focal-16 main'
sudo apt update
sudo apt install -qy clang-16 lld-16 libc++-16-dev libc++abi-16-dev
- name: Clang-16 build and Test
env:
CC: clang-16
CXX: clang++-16
# TODO: add '-Werror' after fixing ICU-22873
CPPFLAGS: '-Wall -Wextra -Wno-strict-prototypes -Wctad-maybe-unsupported'
CXXFLAGS: ${{ matrix.flags }}
run: |
cd icu4c/source && ./runConfigureICU --enable-debug --disable-release Linux/clang && make -j -l4.5 check
# MacOS with clang
macos-clang:
runs-on: macos-latest
@ -247,11 +348,163 @@ jobs:
- uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
- name: ICU4C with clang on MacOS
env:
# TODO: add '-Werror' after fixing ICU-22874
CPPFLAGS: '-Wall -Wextra -Wextra-semi -Wundef -Wnon-virtual-dtor -Wctad-maybe-unsupported'
run: |
cd icu4c/source;
PYTHON=python3 ./runConfigureICU MacOSX;
make -j -l4.5 check
# Windows MSVC builds
windows-msvc:
runs-on: windows-2022
strategy:
fail-fast: false
matrix:
include:
- test_flags: 'x64 Debug'
build_flags: '/p:Configuration=Debug /p:Platform=x64'
- test_flags: 'x86 Debug'
build_flags: '/p:Configuration=Debug /p:Platform=Win32'
- test_flags: 'arm Release'
build_flags: '/p:Configuration=Release /p:Platform=ARM'
- test_flags: 'x64 Release'
build_flags: '/p:LanguageStandard=stdcpplatest /p:Configuration=Release /p:Platform=x64'
- test_flags: 'x64 Release'
build_flags: '/p:_HAS_EXCEPTIONS=0 /p:Configuration=Release /p:Platform=x64'
steps:
- uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
- name: Set up MSBuild
uses: microsoft/setup-msbuild@v2
- name: Build Solution x64
if: contains(matrix.test_flags, 'arm Release')
run: msbuild icu4c/source/allinone/allinone.sln /p:Configuration=Release /p:Platform=x64
- name: Build Solution
run: |
msbuild icu4c/source/allinone/allinone.sln ${{ matrix.build_flags }}
- name: Run ${{ matrix.test_flags }} Tests (icucheck.bat)
if: contains(matrix.test_flags, 'arm Release') == false
run: |
icu4c\source\allinone\icucheck.bat ${{ matrix.test_flags }}
# Windows data filter build
windows-msvc-datafilter:
runs-on: windows-latest
timeout-minutes: 30
steps:
- uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
- name: Set ICU_DATA_FILTER_FILE variable
run: |
$filterPath = "${{ github.workspace }}\.github\data-filter.json"
echo "ICU_DATA_FILTER_FILE=$filterPath" >> $GITHUB_ENV
shell: pwsh
- name: Set up MSBuild
uses: microsoft/setup-msbuild@v2
- name: Build Solution with Data Filter
run: msbuild icu4c/source/allinone/allinone.sln /p:Configuration=Release /p:Platform=x64 /p:SkipUWP=true
# Windows MSVC distribution release
windows-msvc-dist-release:
runs-on: windows-latest
timeout-minutes: 30
strategy:
fail-fast: false
matrix:
include:
- arch: 'x64'
plat: 'x64'
win_ver: 'Win64'
- arch: 'x86'
plat: 'Win32'
win_ver: 'Win32'
- arch: 'arm64'
plat: 'ARM64'
win_ver: 'WinARM64'
steps:
- uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
- name: Set up MSBuild
uses: microsoft/setup-msbuild@v2
- name: Build Solution x64
if: contains(matrix.win_ver, 'ARM64')
run: msbuild icu4c/source/allinone/allinone.sln /p:Configuration=Release /p:Platform=x64
- name: Build Solution
run: msbuild icu4c/source/allinone/allinone.sln /p:Configuration=Release /p:Platform=${{ matrix.plat }}
- name: Run Tests (icucheck.bat)
if: contains(matrix.win_ver, 'ARM64') == false
run: icu4c/source/allinone/icucheck.bat ${{ matrix.arch }} Release
- name: "Run PowerShell: Distrelease script (${{ matrix.arch }})"
run: |
cd ./icu4c/
./packaging/distrelease.ps1 -arch ${{ matrix.arch }}
shell: pwsh
- name: Extract ICU version and rename zip file
id: set-zip-name
run: |
# Extract ICU version from icuver.txt
$icuverContent = Get-Content icu4c\source\data\misc\icuver.txt
$icuVersion = ($icuverContent -match 'ICUVersion{"(\d+\.\d+\.\d+\.\d+)"}')[0]
$icuVersion -match '\{"(.*?)"\}' | Out-Null
$icuVersion = $matches[1]
$majorVersion = $icuVersion.Split('.')[0]
$minorVersion = $icuVersion.Split('.')[1]
# Determine the new file name based on the version
if ($minorVersion -eq "0") {
$newZipName = "icu4c-${majorVersion}rc-${{ matrix.win_ver }}-MSVC2022"
} else {
$newZipName = "icu4c-${majorVersion}_${minorVersion}-${{ matrix.win_ver }}-MSVC2022"
}
# Debugging: Print the new zip name
Write-Host "New Zip Name: $newZipName"
# Rename the existing zip file
cd icu4c\source\dist\ && ls -l .
Rename-Item -Path icu-windows.zip -NewName "${newZipName}.zip"
echo $newZipName
ls -l .
echo "newZipName=$newZipName" | Out-File -FilePath $env:GITHUB_ENV -Append
- name: Upload artifact
uses: actions/upload-artifact@v4
with:
name: icu4c.${{ matrix.win_ver }}.run_#${{ github.run_number }}
path: icu4c/source/dist/${{ env.newZipName }}.zip
# Window MSYS2 tests
windows-msys2-gcc-x86_64:
runs-on: windows-latest
timeout-minutes: 45
defaults:
run:
shell: msys2 {0}
steps:
- uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
- name: Set up MSYS2
uses: msys2/setup-msys2@v2
id: msys2
with:
update: true
msystem: mingw64
install: >
base-devel
mingw-w64-x86_64-toolchain
make
- name: 'Verify MinGW Installation'
run: gcc --version
- name: Build and Test
run: |
cd '${{ github.workspace }}' && cd icu4c/source && ./runConfigureICU MinGW --prefix='/tmp/build-icu' && make -j -l4.5 check
- name: Make install
run: |
cd '${{ github.workspace }}' && cd icu4c/source && make install && cd /tmp/build-icu && echo 'Recursive ls' && ls -lR
- name: Run icuinfo
run: |
echo 'Run icuinfo from MSYS shell' && cd /tmp/build-icu/bin && ./icuinfo.exe
- name: Run icuinfo from CMD
shell: cmd
run: |
cd /d ${{ steps.msys2.outputs.msys2-location }}\tmp\build-icu\bin
set PATH=C:\tools\msys64\mingw64\bin;%PATH%
.\icuinfo.exe
# Run ICU4C tests with stubdata.
run-with-stubdata:
runs-on: ubuntu-latest
@ -593,3 +846,75 @@ jobs:
mkdir -p lib
pushd common && make -j -l4.5 && popd
pushd i18n && make -j -l4.5 && popd
# Workflow for ICU Export Data for ICU4X
icu4c-icuexportdata:
runs-on: ubuntu-latest
timeout-minutes: 30
steps:
- uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
- name: Build
run: |
cd icu4c/source && ./runConfigureICU Linux && make -j -l4.5
env:
CC: clang
CXX: clang++
- name: Build property data files
run: |
cd icu4c/source
mkdir -p icuexportdata/uprops/fast
./bin/icuexportdata --mode uprops --index --copyright --verbose --destdir icuexportdata/uprops/fast --trie-type fast --all
mkdir -p icuexportdata/uprops/small
./bin/icuexportdata --mode uprops --index --copyright --verbose --destdir icuexportdata/uprops/small --trie-type small --all
env:
LD_LIBRARY_PATH: lib
- name: Build normalization data files
run: |
cd icu4c/source
mkdir -p icuexportdata/norm/fast
./bin/icuexportdata --mode norm --index --copyright --verbose --destdir icuexportdata/norm/fast --trie-type fast --all
mkdir -p icuexportdata/norm/small
./bin/icuexportdata --mode norm --index --copyright --verbose --destdir icuexportdata/norm/small --trie-type small --all
env:
LD_LIBRARY_PATH: lib
- name: Build case data files
run: |
cd icu4c/source
mkdir -p icuexportdata/ucase/fast
./bin/icuexportdata --mode ucase --index --copyright --verbose --destdir icuexportdata/ucase/fast --trie-type fast --all
mkdir -p icuexportdata/ucase/small
./bin/icuexportdata --mode ucase --index --copyright --verbose --destdir icuexportdata/ucase/small --trie-type small --all
env:
LD_LIBRARY_PATH: lib
- name: Build collation data files
run: |
cd icu4c/source
cd data/coll
FILES=$(ls *.txt)
cd ../../
mkdir -p icuexportdata/collation/unihan
./bin/genrb -X -s data/coll --ucadata data/in/coll/ucadata-unihan-icu4x.icu -d icuexportdata/collation/unihan $FILES
rm icuexportdata/collation/unihan/*.res
mkdir -p icuexportdata/collation/implicithan
./bin/genrb -X -s data/coll --ucadata data/in/coll/ucadata-implicithan-icu4x.icu -d icuexportdata/collation/implicithan $FILES
rm icuexportdata/collation/implicithan/*.res
env:
LD_LIBRARY_PATH: lib
- name: Build segmenter dictionary files
run: |
cd icu4c/source
mkdir -p icuexportdata/segmenter/dictionary
for FILE in $(ls data/brkitr/dictionaries | xargs -n 1 basename); do
./bin/gendict --uchars --toml data/brkitr/dictionaries/$FILE icuexportdata/segmenter/dictionary/$(basename $FILE .txt).toml
done
env:
LD_LIBRARY_PATH: lib
- name: Zip
run: |
cd icu4c/source/icuexportdata
zip -r ../../../icuexportdata_tag-goes-here.zip .
- name: Publish Artifact
uses: actions/upload-artifact@v4
with:
name: icuexportdata_output
path: icuexportdata_tag-goes-here.zip

69
.github/workflows/icu_exhaustive_tests.yml vendored Normal file
View file

@ -0,0 +1,69 @@
# Copyright (C) 2016 and later: Unicode, Inc. and others.
# License & terms of use: http://www.unicode.org/copyright.html
#
# GitHub Actions configuration for Exhaustive Tests for ICU.
#
# Note: The exhaustive test configuration is in a separate file
# so that it can be run independently from the regular builds.
#
# To run these tests, go to the Actions Tab of your repo on the github page,
# select "Exhaustive Tests for ICU" and manually trigger the workflow for your branch.
name: Exhaustive Tests for ICU
on:
push:
# Runs post merge on maintenance branches
branches:
- 'maint/maint*'
paths:
- 'icu4c/**'
- 'icu4j/**'
- '.github/workflows/**'
schedule:
# Runs daily on default branch (main) only.
# https://docs.github.com/en/actions/writing-workflows/choosing-when-your-workflow-runs/events-that-trigger-workflows#schedule
- cron: '0 4 * * 6' # Run every Saturday at 4:00 UTC
workflow_dispatch:
# Run manually on any branch
# For non-release branches (namely: PRs), only run CI on the most recent commit. Cancel
# runs on previous commits mid-flight when new commits are pushed.
# https://docs.github.com/en/actions/using-jobs/using-concurrency#example-only-cancel-in-progress-jobs-on-specific-branches
concurrency:
group: ${{ github.workflow }}-${{ github.ref }}
cancel-in-progress: ${{ !contains(github.ref, 'maint/') && github.ref != 'main' }}
jobs:
# Runs exhaustive tests for ICU4J on Linux
icu4j-linux:
runs-on: ubuntu-latest
timeout-minutes: 180
steps:
- uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
- name: Build and Exhaustive Tests
run: |
echo "Building ICU4J" && cd icu4j && mvn install -DICU.exhaustive=10
env:
BUILD: ICU4J
- name: List failures (if any)
if: failure()
run: |
cd icu4j && cat `find . -name surefire-reports -type d -exec grep -l -r --include="*.txt" FAILED {} \;`
timeout-minutes: 2
icu4c-linux-clang:
runs-on: ubuntu-latest
timeout-minutes: 120
steps:
- uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
- name: Build
run: |
cd icu4c/source && ./runConfigureICU Linux/clang && make -j -l4.5
- name: Exhaustive Tests
run: |
cd icu4c/source && make check-exhaustive
env:
CC: clang
CXX: clang++

82
.github/workflows/icu_merge_ci.yml vendored
View file

@ -824,3 +824,85 @@ jobs:
publish_branch: main
publish_dir: ./perf
keep_files: true
# Build ICU and tests sample on some windows configurations
icu4c-windows-msvc-postmerge:
runs-on: windows-2022
timeout-minutes: 30
strategy:
matrix:
arch: [x64, x86]
config: [Debug, Release]
include:
- arch: x86
platform: Win32
- arch: x64
platform: x64
steps:
- uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
- name: Set up MSBuild
uses: microsoft/setup-msbuild@v1
- name: Build Solution
run: msbuild icu4c/source/allinone/allinone.sln /p:Configuration=${{ matrix.config }} /p:Platform=${{ matrix.platform }}
- name: Run Tests (icucheck.bat)
run: icu4c/source/allinone/icucheck.bat ${{ matrix.arch }} ${{ matrix.config }}
- name: Build Sample Solution
run: msbuild icu4c/source/samples/all/all.sln /p:Configuration=${{ matrix.config }} /p:Platform=${{ matrix.arch }}
- name: Test Samples (samplecheck.bat)
run: icu4c/source/samples/all/samplecheck.bat ${{ matrix.arch }} ${{ matrix.config }}
icu4c-windows-cygwin-gcc:
runs-on: windows-latest
timeout-minutes: 50
env:
ICU_CI_CACHE: c:\icu-ci-cache
CYG_URL: https://cygwin.com/setup-x86_64.exe
CYG_MIRROR: http://mirrors.kernel.org/sourceware/cygwin/
CYG_PACKAGES: automake,gcc-core,gcc-g++,make,pkg-config,perl,python3
CYG_ROOT: c:\cygwin-root
CYG_CACHE: 'c:\icu-ci-cache\cygwin64-v3'
CYG_CACHED_SETUP: 'c:\icu-ci-cache\cygwin64-v3\setup.exe'
CYG_VERSION_KEY: cygwin-3.2
defaults:
run:
shell: cmd
steps:
- name: Configure Git to checkout with Unix line endings (LF)
run: |
git config --global core.autocrlf input
- uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
- name: Restore Cygwin cache
uses: actions/cache@v2
with:
path: ${{ env.CYG_CACHE }}
key: ${{ hashFiles('.github/workflows/icu_merge_ci.yml') }}
- name: Download Cygwin setup
shell: pwsh
run: |
if ( !(Test-Path "${{ env.CYG_CACHED_SETUP }}" -NewerThan (Get-Date).AddDays(-7)) )
{
Write-Host "Cached Cygwin setup does not exist or is older than 7 days, downloading from external site."
New-Item -Force -Type Directory ${{ env.CYG_CACHE }}
Write-Host "Downloading Cygwin setup..."
$start_time = Get-Date
(New-Object System.Net.WebClient).DownloadFile("${{ env.CYG_URL }}", "${{ env.CYG_CACHED_SETUP }}")
Write-Output "Download took: $((Get-Date).Subtract($start_time).Seconds) second(s)."
}
- name: Install Cygwin
run: |
${{ env.CYG_CACHED_SETUP }} --no-verify --quiet-mode --no-shortcuts --no-startmenu --no-desktop --upgrade-also --only-site --site "${{ env.CYG_MIRROR }}" --root "${{ env.CYG_ROOT }}" --local-package-dir "${{ env.CYG_CACHE }}" --packages "${{ env.CYG_PACKAGES }}"
- name: Check Cygwin environment
run: |
${{ env.CYG_ROOT }}/bin/sh -lc 'echo Hello' && ${{ env.CYG_ROOT }}/bin/sh -lc 'uname -a'
- name: Build ICU (source and test)
run: |
${{ env.CYG_ROOT }}/bin/bash -lc "cd $(cygpath \"${{ github.workspace }}\") && cd icu4c/source && ./runConfigureICU Cygwin && make tests -j -l4.5"
env:
CC: gcc
CXX: g++
- name: Run Tests
run: |
${{ env.CYG_ROOT }}/bin/bash -lc "cd $(cygpath \"${{ github.workspace }}\") && cd icu4c/source && make -j -l4.5 check"
env:
CC: gcc
CXX: g++

6
docs/processes/cldr-icu.md
View file

@ -379,12 +379,12 @@ If the data is OK , other sources of failure can include:
Exhautive tests should always be run for a CLDR-ICU integration PR before it is merged.
Once you have a PR, you can do this for both C and J as part of the pre-merge CI tests
by adding the following as a comment in the pull request:<br>
`/azp run CI-Exhaustive` (the exhaustive tests are not run automatically on every PR).
by manually running a workflow (the exhaustive tests are not run automatically on every PR).
See [Continuous Integration / Exhaustive Tests](../userguide/dev/ci.md#exhaustive-tests).
The following instructions run the ICU4C exhaustive tests locally (which you may want to do
before even committing changes, or which may be necessary to diagnose failures in the
CI tests:
CI tests):
```
cd $ICU4C_DIR/source
export INTLTEST_OPTS="-e"

2
docs/processes/release/tasks/healthy-code.md
View file

@ -474,7 +474,7 @@ make check
## Test ICU4C Samples and Demos
### Windows build and test
Note: Since ICU 73, this task has been included in the Azure DevOps Pipeline which is triggered automatically upon merging with main/maint* branches.
Note: Since ICU 76, this task has been included in the GHA workflows which are triggered automatically upon merging with main/maint* branches.
These instructions explain how to run the tests manually.
To build the ICU4C samples on Windows with Visual Studio, use the following

BIN
docs/processes/release/tasks/publish/azure-ci-builds-artifacts-download.png
View file

Binary file not shown.
Side by side

Before

(image error) Size: 6.8 KiB

BIN
docs/processes/release/tasks/publish/azure-ci-builds-artifacts.png
View file

Binary file not shown.
Side by side

Before

(image error) Size: 6 KiB

BIN
docs/processes/release/tasks/publish/azure-ci-builds.png
View file

Binary file not shown.
Side by side

Before

(image error) Size: 12 KiB

BIN
docs/processes/release/tasks/publish/gha-ci-artifacts.png Normal file
View file

Binary file not shown.
Side by side

After

(image error) Size: 24 KiB

BIN
docs/processes/release/tasks/publish/gha-ci-summary.png Normal file
View file

Binary file not shown.
Side by side

After

(image error) Size: 40 KiB

40
docs/processes/release/tasks/publish/index.md
View file

@ -309,36 +309,24 @@ run \`make dist\`.
* Click on the green check mark (✔) on the most recent/last commit. (It
might be a red X if the builds failed, hopefully not).
* This will open up a pop-up with links to various CI builds.
* Click on one of the various links that says "Details" for the Azure CI
builds.
* Click on one of the various links that says "Details" for any of the GHA
builds and click on "Summary".
* This will open up the GitHub overview of the build status.<br>
![image](azure-ci-builds.png)<br>
* Click on the link "View more details on Azure Pipelines" link.
* This will take you to the actual Azure CI build page.
* On the top right of the page there should be a button titled
"Artifacts". Click this and it should show a drop-down with various ZIP
files that you can download.<br>
![image](azure-ci-builds-artifacts.png)<br>
* The ZIP may automatically download for you.
* However, if you are signed-in to visualstudio.com then you might see a
dialog titled "Artifacts explorer".
* In this case click on the name, then the "..." button to download the
zip file.<br>
![image](azure-ci-builds-artifacts-download.png)<br>
* Download both the x64 (64-bit) and x86 (32-bit) ZIP files.
![image](gha-ci-summary.png)<br>
* Scroll down at the bottom to find the sub-section "Artifacts". It should show you list of zips you can download<br>
![image](gha-ci-artifacts.png)<br>
* Download the x64, x86 and ARM zip files.
* For each architecture:
* Extract the Zip file. (It will have a name like
"20190829.6_ICU4C_MSVC_x64_Release.zip").
"icu4c.Win64.run_#104.zip").
* Navigate into the folder with the same name.
* Rename the file "icu-windows.zip" to the appropriate name:
* Ex: The x64 zip for version 64.1 was named
"icu4c-64_1-Win64-MSVC2017.zip"
* Ex: The x86 zip for version 64.1 was named
"icu4c-64_1-Win32-MSVC2017.zip"
* Note: Note: As of ICU 68, the pre-built binaries use MSVC2019
instead of MSVC2017.
* Check and verify the names of the zip file are appropriate:
* Ex: The x64 zip for version 76.1 should be named
"icu4c-76_1-Win64-MSVC2022.zip"
* Ex: The x86 zip for version 76.1 should be named
"icu4c-76_1-Win32-MSVC2022.zip"
* Note: For RC releases the name looked like this:
"icu4c-64rc-Win64-MSVC2017.zip"
"icu4c-76rc-Win64-MSVC2022"
* ~~AIX Bin:~~ (AIX is broken and ignored for now.)
* ~~login to gcc119.fsffrance.org and copy the ICU4C source archive
created above to there.~~
@ -360,7 +348,7 @@ run \`make dist\`.
This step publishes pre-processed Unicode property data, which may be ingested by downstream clients such as ICU4X.
* Using the output from the build bots:
* Navigate to the Azure Pipeline `C: Create Artifacts from icuexportdata` and download its single artifact (`icuexportdata_output`)
* Navigate to the GHA Workflow `icu4c-icuexportdata` and download the artifact (`icuexportdata_output`) from summary page
* Unzip the file
* Rename the `icuexportdata_tag-goes-here.zip` file to the correct tag (replacing slashes with dashes)

BIN
docs/userguide/assets/gha_run_workflow.png Normal file
View file

Binary file not shown.
Side by side

After

(image error) Size: 12 KiB

BIN
docs/userguide/assets/gha_tab.png Normal file
View file

Binary file not shown.
Side by side

After

(image error) Size: 22 KiB

83
docs/userguide/dev/ci.md
View file

@ -30,10 +30,7 @@ ICU4J's unit tests in JUnit).
ICU uses Continuous Integration systems to run these tests automatically for each new code contribution,
and upon each update to a future contribution under development
(that is: for each [successful Pull Request merge, and upon a new push of new git commits to a Pull Request](../gitdev.md)).
ICU has 2 systems configured to run Continuous Integration testing:
* Github Actions
* Azure Pipelines
ICU has GitHub Actions configured to run Continuous Integration testing.
Continuous Integration systems can also be used to regularly and automatically run other tasks besides testing.
ICU uses a CI workflow to automatically publish changes to its User Guide that is hosted on Github Pages.
@ -121,70 +118,18 @@ the workflow will not run and Github is not capable of ignoring the check in tha
Open Source users can now access machines with [at least 4 cores available per job](https://github.blog/2024-01-17-github-hosted-runners-double-the-power-for-open-source/).
## Azure Pipelines
### Exhaustive Tests
Exhaustive tests run tests on a larger, more complete dataset than the regular unit tests.
The larger dataset makes them run much longer than an individual unit test.
Thus, exhaustive tests are not run automatically on every PR.
They must pass before new versions of CLDR can be integrated into ICU,
which is a part of the release process.
ICU also uses [Azure Pipelines](https://azure.microsoft.com/en-us/products/devops/pipelines) to run CI jobs.
It may be desirable to run exhaustive tests manually on a PR for areas of code that are known to need the extra test coverage provided by exhaustive tests.
To trigger exhaustive tests manually:
### Workflow files
Workflow files are in YAML form stored at `.ci-builds/`.
### UI Dashboard
All Azure piplines show up in the
[Azure Piplines ICU project dashboard](https://dev.azure.com/ms/icu/),
specifically in the
[Pipelines page](https://dev.azure.com/ms/icu/_build).
After clicking on a specific pipeline,
all of the instances/runs for that pipeline appear.
All of the runs can be filtered in the Branch filter by the destination branch name (ex: `main`) or the PR number (ex: `2874`).
### Configuration
#### Initial Setup with Github.
The upstream Github repo needs to be connected to Azure Pipelines in order for Azure Pipelines to listen for and trigger new pipelines based on events occuring in Github,
and to return the status back to Github.
This configuration is started by ensuring that the upstream ICU repo `unicode-org/icu` has the Azure Pipelines 3rd party app installed from the Github Marketplace.
Once installed, the app will appear in the repo's Github "Settings" page under "Integrations" > "Github Apps".
In order to configure a newly pipeline in Azure using the Github app for Azure Pipelines, you must do:
1. Create and check-in a new YAML file in the icu repo at `.ci-builds/`
2. In the repo settings, go to "Github Apps"
3. In the Installed GitHub Apps section, click option to configure "Azure Pipelines".
4. A page to update Azure Pipeline's repository access apears next. Click on "Update access".
5. Next a page to authenticate with your Microsoft credentials appear. Sign in with Microsoft credentials.
6. Select ADO org as `ms` and project as `icu`, click on continue.
7. After authentication from Azure and Github, you come to the new pipeline wizard.
8. Select repo as `unicode-org/icu` and select "Existing Azure Pipelines YAML file" and choose the yaml file created in step #1
9. Review YAML file and click save. You will find a new pipeline created with name `unicode-org.icu`. Rename it to a more appropriate name
***The pipline should now run as per the YAML rules and would be visible from Github settings for branch protection.***
#### Jobs
Jobs can be added, removed, and edited merely by editing the YAML workflow files.
The syntax for Azure Pipelines workflows is very similar to Github Actions, including the YAML format.
However, there are noteworthy differences in functionality and the expression of equivalent configurations aross the systems and syntaxes.
#### Conditional Triggers
Conditional triggers can be configured for Azure Pipelines similarly to Github Actions.
Note: The triggers for merges to a branch (ex: `main`) may need to be duplicated into a separate trigger section for Pull Requests because they seem to be handled differently.
### Caveats
In order to set up a pipeline, a person must simultaneously have access to the Azure Pipelines project for ICU and to the Github ICU repository.
If an Azure Pipeline only has one job,
that job might not be shown on a PR's main page within the list of all of the running CI checks.
There will only be an entry with the pipeline name in the list of checks.
However, if an Azure Pipeline has multiple jobs,
then each of the constituent jobs of the pipeline will be represent in the list of checks,
in addition to an entry for the pipeline itself.
1. Go to your respective fork of the project (username/icu) if the PR is not already merged. Otherwise, go to https://github.com/unicode-org/icu
2. Select on the "Actions" tab from the top bar
![GHA Actions](../assets/gha_tab.png)
3. On the left pane under All workflows, find "Exhaustive Tests for ICU" and click on run workflow, select branch and click 'Run workflow'.
![Run Workflow](../assets/gha_run_workflow.png)

17
docs/userguide/dev/gitdev.md
View file

@ -591,16 +591,9 @@ Send the PR off for review. As in the Easy Way, **you should use the MERGE COMMI
## Requesting an Exhaustive Test run on a Pull-Request (PR)
The ICU4C and ICU4J Exhaustive Tests run on the main branch after a pull-request
has been submitted. They do not run on pull-requests by default as they take 1-2
hours to run.
The ICU4C and ICU4J Exhaustive Tests run on the main branch periodically once
every Saturday (at 4:00 AM UTC) and post merging on the maintenance branches.
They do not run on pull-requests by default as they take 1-2 hours to run.
However, you can manually request the CI builds to run the exhaustive tests on a
PR by commenting with the following text:
```
/azp run CI-Exhaustive
```
This will trigger the test run on the PR. This is covered more in a separate
[document](https://docs.google.com/document/d/1kmcFFUozpWah_y7dk_Inlw_BIq3vG3-ZR2A28tIiXJc/edit?usp=sharing).
However, you can manually request the CI builds to run the exhaustive tests.
See [Continuous Integration / Exhaustive Tests](../userguide/dev/ci.md#exhaustive-tests).