{Secure Systems and Programmable Networks: Tools for the Future}

$ git config

$ git add
$ git rm 
$ git mv
$ git commit -m 'desc commit'

$ git checkout -b branch_name # craete a new branch
$ git checkout branch_name
$ git merge REMOTE BRANCH # ex. git merge origin master

$ git reset
$ git revert

$ git status
$ git log
$ git diff

$ git init
$ git clone
$ git remote → git remote add, git remote -v, git remote rm
$ git fetch

$ git pull
$ git push

$ git config --global user.name "Stefano Borzì"
$ git config --global user.email "stefano@example.com"
$ git config --global core.editor nano


$ git config --list
user.name=Stefano Borzì
user.email=stefano@example.com
core.editor=nano
...


$ git config user.name
Stefano Borzì

$ git init

$ git add
$ git rm 
$ git mv

$ git status
$ git diff

$ git commit -m 'desc commit'

$ git log

/*
Make a BRANCH per each task.

- fix warning and errors
- fix the code
- make N dynamic, let the user choose N
- remove unused
- make some improvements on your own
*/

$ git config

$ git init

$ git add
$ git rm 
$ git mv
$ git commit -m 'desc commit'

$ git checkout -b branch_name # craete a new branch
$ git checkout branch_name
$ git merge BRANCH # ex. git merge feature-1

$ git reset
$ git revert

$ git status
$ git log
$ git diff

name: Hello-World

on:
  push:
    branches: [main]
  pull_request:
    branches: [main]

jobs:
  hello-world-job:

    runs-on: ubuntu-latest

    steps:
      - name: Hello World
        run: echo 'Hello World'

name: build-hello-world

on:
  push:
    branches: [main]
  pull_request:
    branches: [main]

jobs:
  build-hello-world:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: install g++
        run: sudo apt install -y g++

      - name: check build
        run: |
          g++ hello_world.cpp -o hello_world
          ./hello_world

name: release-hello-world

on:
  workflow_dispatch:

jobs:
  build-hello-world:
    permissions: write-all
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: compile and run
        run: g++ hello_world.cpp -o hello_world_linux

      - name: Create Release
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
        run: >-
          gh release create ${{ github.ref_name }}
          "hello_world_linux"
          --generate-notes
          --title "Version ${{ github.ref_name }}"

name: release-hello-world

on:
  workflow_dispatch:

jobs:
  create-release:
    permissions: write-all
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Create Release
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
        run: gh release create ${{ github.ref_name }} --generate-notes --title "Version ${{ github.ref_name }}"

  build-hello-world:
    needs: create-release
    permissions: write-all

    strategy:
      matrix:
        include:
          - os: ubuntu-latest
            file_name: hello_world_linux
          - os: macos-latest
            file_name: hello_world_mac
          - os: windows-latest
            file_name: hello_world_windows.exe

    runs-on: ${{ matrix.os }}
    name: ${{ matrix.os }}

    steps:
      - uses: actions/checkout@v4
      - name: compile
        run: g++ hello_world.cpp -o ${{ matrix.file_name }}

      - name: Update Release
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
        run: gh release upload ${{ github.ref_name }} "${{ matrix.file_name}}"

name: build-hello-world

on:
  push:
    branches: [main]
  pull_request:
    branches: [main]

jobs:
  build-hello-world:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: install g++
        run: sudo apt install -y g++

      - name: check build
        run: |
          g++ hello_world.cpp -o hello_world
          ./hello_world

#include <iostream>
using namespace std;

int main() {

  cout << "Hello World" << endl;

  return 0;
}

#include <iostream>
using namespace std;

int main() {
  int x;
  cout << x << endl;

  cout << "Hello World" << endl;

  return 0;
}

#include <iostream>
using namespace std;

int main() {
  int* p = nullptr;

  cout << *p << endl;

  cout << "Hello World" << endl;

  return 0;
}

name: build-hello-world

on:
  push:
    branches: [main]
  pull_request:
    branches: [main]

jobs:
  build-hello-world:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: install g++
        run: sudo apt install -y g++ cppcheck

      - name: run cppcheck
        run: |
          cppcheck hello_world.cpp --output-file=report.txt
          if [ -s report.txt ]; then # if file is not empty
            cat report.txt
            exit 1 # let github action fails
          fi

      - name: check build
        run: |
          g++ hello_world.cpp -o hello_world
          ./hello_world

name: CI

on:
  push:
    branches: [main]
    paths-ignore:
      - "README.md"
      - "docs/**"
  pull_request:
    branches: [main]
    paths-ignore:
      - "README.md"
      - "docs/**"

jobs:
  test:
    runs-on: ubuntu-latest

    steps:
      - uses: actions/checkout@v2

      - name: Set up Python 3.10.0
        uses: actions/setup-python@v2
        with:
          python-version: 3.10.0

      - name: Install dependencies for requirements and testing
        run: |
          python -m pip install --upgrade pip
          if [ -f requirements.txt ]; then pip install -r requirements.txt; fi
          if [ -f requirements_dev.txt ]; then pip install -r requirements_dev.txt; fi

      - name: Lint with pylint
        run: pylint src

      - name: Test with pytest
        run: pytest --cov src tests/ --cov-fail-under=75

name: Create and publish a Docker image

on:
  workflow_call:
    inputs:
      repo_ref: # "author/repository_name" or ${{ github.repository }}
        required: true
        type: string

env:
  REGISTRY: ghcr.io
  IMAGE_NAME: ${{ inputs.repo_ref }}

jobs:
  build-and-push-image:
    runs-on: ubuntu-latest
    permissions:
      contents: read
      packages: write

    steps:
      - name: Checkout repository
        uses: actions/checkout@v2

      - name: Log in to the Container registry
        uses: docker/login-action@f054a8b539a109f9f41c372932f1ae047eff08c9
        with:
          registry: ${{ env.REGISTRY }}
          username: ${{ github.actor }}
          password: ${{ secrets.GITHUB_TOKEN }}

      - name: Extract metadata (tags, labels) for Docker
        id: meta
        uses: docker/metadata-action@98669ae865ea3cffbcbaa878cf57c20bbf1c6c38
        with:
          images: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}

      - name: Build and push Docker image
        uses: docker/build-push-action@ad44023a93711e3deb337508980b4b5e9bcdc5dc
        with:
          context: .
          push: true
          tags: ${{ steps.meta.outputs.tags }}
          labels: ${{ steps.meta.outputs.labels }}

name: Create and publish a Docker image
on:
  push:
    branches:
      - 'main'

jobs:
  build:
    uses: unict-dmi/reusable-workflows/.github/workflows/docker.yml@main
    with:
      repo_ref: ${{ github.repository }}

name: Telegram-Secret-Token

on:
  push:
    branches: [main]
  pull_request:
    branches: [main]

jobs:
  hello-world-job:

    runs-on: ubuntu-latest

    steps:
      - name: Telegram Notify
        run: >-
          curl -s --data-urlencode "text=Hello World ✅"
          "https://api.telegram.org/bot${{ secrets.MY_SECRET_TOKEN }}/sendMessage?chat_id=1044003630" > /dev/null

#include <iostream>
using namespace std;

int SafeDivide(int a, int b) {
    cout << "a: " << a << endl;
    cout << "b: " << b << endl;

    if (b == 0) {
        return 0; // Return 0 if division by zero
    }

    return a / b;
}


int main() {
    int a, b;

    cout << "Enter a: ";
    cin >> a;

    cout << "Enter b: ";
    cin >> b;

    cout << SafeDivide(a, b) << endl;

    return 0;
}

#include <gtest/gtest.h>
#include "math_utils.h"

TEST(MathUtilsTest, HandlesZeroDivision) {
    EXPECT_EQ(SafeDivide(10, 0), 0);
}

TEST(MathUtilsTest, HandlesNormalDivision) {
    EXPECT_EQ(SafeDivide(10, 2), 5);
}

#include "math_utils.h"

int SafeDivide(int a, int b) {
    if (b == 0) {
        return 0; // Return 0 if division by zero
    }

    return a / b;
}

#pragma once

int SafeDivide(int a, int b);

#include <cstdint>
#include <cstddef>
#include "math_utils.h"

extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
    if (size < 8) return 0;

    int a = *(reinterpret_cast<const int*>(data));
    int b = *(reinterpret_cast<const int*>(data + 4));

    SafeDivide(a, b);

    return 0;
}

name: fuzz-test-example

on:
  push:
    branches: [main]
  pull_request:
    branches: [main]

jobs:
  fuzz-test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: install g++
        run: sudo apt install -y g++

      - name: run build, test and fuzz test
        run: |
          mkdir build
          cd build
          cmake .. -DCMAKE_CXX_COMPILER=clang++
          cmake --build . -- -j$(nproc)
          ./math_utils_test
          timeout 30 ./fuzz_math_utils || echo "Fuzz test crashed or timed out"
          if ls crash-* 1> /dev/null 2>&1; then
            hexdump -v -e '"%d, "' -e '8/1 "0x%02x, " "\n"' ./crash-*
            exit 1 # let github action fails
          fi
          echo "Build, test and fuzz test completed successfully"

#include <iostream>
using namespace std;

int SafeDivide(int a, int b) {
    cout << "a: " << a << endl;
    cout << "b: " << b << endl;

    if (b == 0) {
        return 0; // Return 0 if division by zero
    }

    if (a == -2147483648 && b < 0) {
        return 2147483647; // Handle overflow case
    }

    return a / b;
}


int main() {
    int a, b;

    cout << "Enter a: ";
    cin >> a;

    cout << "Enter b: ";
    cin >> b;

    cout << SafeDivide(a, b) << endl;

    return 0;
}