2023年9月17日

Android API33に対応してなかったアプリ

 以前作っていた QRコードを読み込んだり、クリップボードのテキストを QRコード画像にしたりするアプリ。

QRcode Read/Gen - Google Play のアプリ
https://play.google.com/store/apps/details?id=com.hiro99ma.qrgenread

放置していたのだが、Google Play Console から警告がずいぶん前に来ていたことに気付く。

compileSdk と targetSdk を 30 にしていたのだが、ちゃんと更新していきなさいということだろう。

面倒ではあるが、まあ仕方ない。

というよりも、数週間過ぎてしまったのだがどうなったんだろう?

WSL2を仕事で使ってみよう

7年ほど使っていたノートPCを新調した。
私はWindows生活が長いので、今回もWindowsだ。 

Windows11 Home では初回は Microsoftアカウントしかアカウントを作ることができず、ユーザフォルダ名はそのメールアドレスの先頭5文字までを使うという哀しい仕様であることを知った。「それくらい決めさせてくれても良くない??」と思うのは私だけではないようで、検索すると出てきた。変更はできないので別のローカルアカウントを作るしかないことだった。おかげでまだ2アカウントある状態だ。

そういう脱線話はよいとして。

私のソフトウェア開発作業はLinux向けがほとんどだ。
デスクトップPCはストレージに余裕があったし増やしやすいのもあって VirtualBox でやっている。Samba で共有しておけばファイル移動も楽だし、Windows の手慣れたツールを使うこともできて便利である。

が、ノートPCはストレージを増やしにくい。
VDI みたいなサイズが減らしにくいファイルがあると窮屈である。
そこで WSL2 だ。
かなり使えるとは聞いているものの業務として使えるかまでは調べていなかった。
真面目に検討しよう。


まずストレージのことから。

WSL ディスク領域を管理する方法 | Microsoft Learn https://learn.microsoft.com/ja-jp/windows/wsl/disk-space
  • 仮想ハードディスク方式
  • 自動でリサイズされる
  • 初期の割り当てサイズは 1TB

 1TB 確保されるというわけではなく、それだけ割り当てることができますよという値だろう。

 とりあえずインストールしてみよう。

WSL のインストール | Microsoft Learn
https://learn.microsoft.com/ja-jp/windows/wsl/install

ノートPCはまだ一度もWSL2を使ったことが無いのでちょうど良いだろう。


まず wsl --install の実行直後。
昔は Linuxサブシステムを使うための設定を行う必要があったが、最近はコマンドの実行で全部やってくれるようだ。ありがたい。

空き容量が 2GB 減った。
内訳としては「システムと予約済み」が 1GB、「インストールされているアプリ」が 1GB 、「その他」が 0.04GB、「他のユーザー」が 0.03GB だった。
この PC はアカウントが 2ユーザー分あり、自分以外のアカウントが増えたのか WSL の分が増えたのかはよくわからない。
ディストリビューションは選択していないので Ubuntu がインストールされていた。

では、初めて Ubuntu を起動してみよう。
インストールされていたのは「Ubuntu 22.04.2 LTS (GNU/Linux 5.15.90.1-microsoft-standard-WSL2 x86_64)」だった。

空き容量が 2GB 減った。
使用領域は 1.5GB 

「システムと予約済み」が 0.2GB、「インストールされているアプリ」が 1.1GB、「その他」が 0.03GB、「他のユーザー」が 0.07GB 増えていた。

df -h しておく。
ルート / に 1007 GB 割り当てられているのが、初期の割り当て 1TB という部分だろう。

Filesystem      Size  Used Avail Use% Mounted on
none            7.8G  4.0K  7.8G   1% /mnt/wsl
none            237G   79G  159G  34% /usr/lib/wsl/drivers
none            7.8G     0  7.8G   0% /usr/lib/wsl/lib
/dev/sdc       1007G  1.3G  955G   1% /
none            7.8G   84K  7.8G   1% /mnt/wslg
rootfs          7.8G  1.9M  7.8G   1% /init
none            7.8G  928K  7.8G   1% /run
none            7.8G     0  7.8G   0% /run/lock
none            7.8G     0  7.8G   0% /run/shm
none            7.8G     0  7.8G   0% /run/user
tmpfs           4.0M     0  4.0M   0% /sys/fs/cgroup
none            7.8G   84K  7.8G   1% /mnt/wslg/versions.txt
none            7.8G   84K  7.8G   1% /mnt/wslg/doc
drvfs           237G   79G  159G  34% /mnt/c
drvfs           224G   53G  171G  24% /mnt/d
drvfs            17G  2.1G   15G  12% /mnt/g
snapfuse        128K  128K     0 100% /snap/bare/5
snapfuse         73M   73M     0 100% /snap/core22/607
snapfuse         92M   92M     0 100% /snap/gtk-common-themes/1535
snapfuse         54M   54M     0 100% /snap/snapd/18933
snapfuse        151M  151M     0 100% /snap/ubuntu-desktop-installer/967


仕事で使うのは、docker, node, golang、あとは必要に応じて。
docker は community版というのかコマンドライン版というのかを普通にインストール。node は nvs 経由。golang は snap で。
docker は usermod し忘れて Permission denied であせったが、まあそういうこともある。docker daemon は service を使って起動させていた記憶があるのだが、今はマシンを再起動して Ubuntu を立ち上げたときには起動していた。いったいいつ起動するんだろうね。

vscode で WSL にログインする extension を入れておけば、当面は困らないだろう。開くフォルダを変更するたびに vscode を開き直すような大げさな動きをするのだけど、まあこれは remote SSH の動作と同じようにしているためなのかね。

 

こういう感じで、以前 docker を使うようにしていたプロジェクトを GitHub から clone して動かしているが、今のところ問題ない。まあ、問題があったら多いにハマりそうなのは仕方あるまい。

2023年9月10日

JavaScriptやTypeScriptで検索しづらい演算子

単語ではないものはネットで検索しづらい。「!」や「?.」などだ。
以前記事にしたようなしてないような・・・忘れたので調べ直す。

 

?.

これは TypeScript ではなく JavaScript にある演算子である。
オプショナルチェーンと呼ぶそうだが、英語では optional chaining だ。

オプショナルチェーン演算子
https://developer.mozilla.org/ja/docs/Web/JavaScript/Reference/Operators/Optional_chaining

ドットまで含めての演算子になっている。ちなみに「.」は chaining operator と呼ぶそうだ。

リンク先では「adventurer」のプロパティに「dog」がないので「adventurer.dog?.name」となっている。
if文にするならこんな感じにして dog の有無を確認するだろう。

if (adventurer.dog) {
  console.log(adventurer.dog.name)
}

チェックをして dog の時点で undefined とわかっているためか「adventurer.dog?.name.hello」でも「adventurer.dog?.name.hello.world」でも、それから先の chaining operator でつないだ部分は気にしないようだ。

次の行の「adventurer.someNonExistentMethod?.()」はメソッドの有無をチェックしている。
こんな感じで定義をしてやれば呼び出される。

const adventurer = {
  ...
  someNonExistentMethod: () => 'hello',
};

まあ、メソッドの有無は大きい問題になりそうだから、通常は if でチェックするんじゃないかな。

 

 

!

これはおそらく TypeScript の演算子だろう。
Non-null assertion operator と呼ばれる。

Non-null assertion operator
https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-0.html#non-null-assertion-operator

これは「なくてもいいですよ」変数の「?」と逆のような意味といってよいかもしれん。

たぶん「なくてもいいですよ」の「?」も TypeScript だと思うが、これは演算子ではなく型定義でしか使えないはずだ。
option parameter と呼ぶそうであるが TypeScript のドキュメントからは見つけられなかった。

 

とはいえ、何に使えるのか。null じゃないですよ、といいつつも実装上 null になることがありうるのをチェックするようになる? でもチェックして何ができるというのか。例外を出して終わらせるのであれば「!」がなくても同じだろう。

こちらによると、コンパイラに明示するのが目的らしい。

TypeScriptでよく見る「?」「!」と仲良くしたい
https://zenn.dev/oreo2990/articles/3d780560c5e552

たしかに、「?」にした変数だったりするとわざわざ if 文で「== null だったら処理を続けない」みたいなのを書かないとエラーになっていた気がするので、そういうのを書かなくてよいのかもしれない。
が、それだったらむしろ if 文にしておかないと危ないのでは? ちょっとテストコードを書くときに、そこで落ちてもいいからコンパイラは無視してくれってことだったらありなのかな。

 

その次に載っていた「明確な割り当てアサーション」は「?」の逆だ。
私はこのオプションを知らなかったが、これも「!」演算子と似たような感じだろう。
確かに書いていてエラーになるのだが、私は初期値を適当に突っ込んでるな。初期値を突っ込むことでロジックが間違っていることには気付きにくくなるかもしれないので、そういうのの洗い出しにはよいかもしれん。

2023年8月20日

golang: interfaceの勉強 (3)

続き。

hiro99ma blog: golang: interfaceの勉強 (2)
https://hiro99ma.blogspot.com/2023/08/golang-interface-2.html


struct と duck typing

golang の調べ物をしたとき、duck typing という言葉を見ることがある。
メソッド名・引数・戻り値が一致したら同じものと思われる、くらいに思っていたのでこういうことができると考えていた。

package main

import "fmt"

type Abc struct{}

func (a *Abc) Greet() {
    fmt.Println("Hello")
}

type Def struct{}

func (d *Def) Greet() {
    fmt.Println("Aloha")
}

func main() {
    abc := new(Abc)
    abc.Greet()
    abc = new(Def)
    abc.Greet()
}

これは赤文字のところでコンパイルエラーになる。コンパイルエラーというか文法エラーというか。

interface Ghi を作ってそこに Greet() を書いておき、使う場合は Ghi の変数として扱ってやると、Abc と Def が Ghi の派生であるとかを匂わせる必要もなく動くようになる。

package main

import "fmt"

type Ghi interface {
    Greet()
}

type Abc struct{}

func (a *Abc) Greet() {
    fmt.Println("Hello")
}

type Def struct{}

func (d *Def) Greet() {
    fmt.Println("Aloha")
}

func main() {
    var abc Ghi
    abc = new(Abc)
    abc.Greet()
    abc = new(Def)
    abc.Greet()
}

struct と interface を関連付けるような記述をしないというところが「プログラミング言語Go」のインターフェースの章で『暗黙的に満足される』といっている意味なんだろう。

暗黙的だと関連性がわからなくて悩みそうだと思ったなら、明示的に書いてもよいだろう。

type Abc struct{ Ghi }

明示的に interface があることを書いておきながらも、interface の方に定義されたメソッドを書いていない場合はコンパイルエラーになりそうだが、そうはならない。
どうなるかというと、未定義のメソッドを呼び出そうとした時点で実行時エラーになる。

panic: runtime error: invalid memory address or nil pointer dereference

package main

import "fmt"

type Ghi interface {
    Greet()
}

type Abc struct{ Ghi }

// func (a *Abc) Greet() {
//     fmt.Println("Hello")
// }

type Def struct{ Ghi }

func (d *Def) Greet() {
    fmt.Println("Aloha")
}

func main() {
    var abc Ghi
    abc = new(Abc)
    abc.Greet()
    abc = new(Def)
    abc.Greet()
}

goalng は全体的に縛り付けるような決まりが少ない気がする。その辺は C言語っぽいなーと感じる。

ともかく、golang は duck typing な言語なのかもしれないが(厳密な定義はよく知らない)、それは何でもかんでもじゃなくて interface が関係した場合だけなんだと思われる。


テストでinterfaceを使おうとする

mock なのか stub なのか driver なのか厳密なところ避けさせてもらう。
本物ではなく偽物にしたいということで fake という言葉を使おう。

テストで fake を使いたい場合、テストしたい関数なりメソッドなりは変更したくないのだが、その中で実際に行う処理は偽物に置き換えたいということだと思う。
ネットワークにアクセスする処理だがエラーを起こしたことにしてテストしたい、とか、ハードウェアにアクセスする処理だが実機では確認できないのでダミーの処理で置き換えたい、とか。

image

まず、テスト対象の関数/メソッドは、その中から呼び出す次の処理を切替ができるように書いておかないといかん。上の図だと黄色の丸で表しているが、これが golang でいうところの関数だったら切り替えるのは難しいだろう(タグで切り替えるということはできそうだが)。

ではメソッドの中から別のメソッドを呼ぶように書くとして、何をどう書くと良いだろう。

Golangにおけるinterfaceをつかったテストで mock を書く技法 - haya14busa
http://haya14busa.com/golang-how-to-write-mock-of-interface-for-testing/

こちらでは、対象となる方は interface を名前を付けて書いている。テスト対象自体が interface を所持しているのではなく外側にあって(所持してても良いだろうが)、new するときに設定しているのか。そして fake の方では interface を無名の埋め込みにしている。

 

ではもうちょっと簡易なコードにして試そう。
mocktest というディレクトリを作り、その中に main.go,  greet/greet.go, greet/machine.go というファイルを置く。

  • main.go
package main

import (
    "fmt"
    "mocktest/greet"
)

func main() {
    g := greet.NewGreet()
    g.SetData(3)
    fmt.Println(g.GetData())
}
  • greet/greet.go
package greet

type Greet struct {
    m     MachineInterface
    value int32
}

func NewGreet() *Greet {
    g := &Greet{}
    g.m = NewMachineData()
    return g
}

func (g *Greet) GetData() int32 {
    return g.value + g.m.Get()
}

func (g *Greet) SetData(value int32) {
    g.value = value
    g.m.Set(value)
}
  • greet/machine.go
package greet

import (
    "math/rand"
    "time"
)

type MachineInterface interface {
    Get() int32
    Set(value int32)
}

type MachineData struct {
    value int32

    r *rand.Rand
}

func NewMachineData() *MachineData {
    m := &MachineData{}
    m.r = rand.New(rand.NewSource(time.Now().UnixNano()))
    return m
}

func (m *MachineData) Get() int32 {
    multi := m.r.Int31n(100)
    return multi * m.value
}

func (m *MachineData) Set(value int32) {
    m.value = value
}

「go run .」などとして実行すると、毎回異なる値が出力されるだろう。
greet/machine.go が乱数を使っていて、ちょっとそのままではテストしづらいというようにしている。やっている内容として意味は無い。 greet/machine.go が制御できない動作をするということだけわかっていればよい。
ここでテストするならば greet/greet.go のメソッドになるし、fake にしたいのは greet/machine.go になる。

では適当にテストコードを書いてみる。

  • greet/greet_test.go
package greet

import (
    "testing"
)

type fakeMachineData struct {
    MachineInterface

    FakeGetData func() int32
    FakeSetData func(value int32)
}

func (f *fakeMachineData) Get() int32 {
    return f.FakeGetData()
}

func (f *fakeMachineData) Set(value int32) {
    f.FakeSetData(value)
}

func TestGetData1(t *testing.T) {
    fakeData := &fakeMachineData{
        FakeGetData: func() int32 {
            return 10
        },
        FakeSetData: func(value int32) {
        },
    }
    mo := NewGreet()
    mo.m = fakeData
    mo.SetData(3)
    value := mo.GetData()
    if value != 13 {
        t.Errorf("GetData: %v", value)
    }
}

func TestGetData2(t *testing.T) {
    fakeData := &fakeMachineData{
        FakeGetData: func() int32 {
            return 15
        },
        FakeSetData: func(value int32) {
        },
    }
    mo := NewGreet()
    mo.m = fakeData
    mo.SetData(5)
    value := mo.GetData()
    if value != 20 {
        t.Errorf("GetData: %v", value)
    }
}

$ go test ./greet/ -v
=== RUN   TestGetData1
--- PASS: TestGetData1 (0.00s)
=== RUN   TestGetData2
--- PASS: TestGetData2 (0.00s)
PASS
ok      mocktest/greet  0.001s

greet/greet_test.go は package が greet なので、小文字のフィールドにもアクセスできる。それを利用して greet.NewGreet() で設定している NewMachineData() を上書きしている。

 

greet/machine.go を別パッケージにしてみよう。
外部のライブラリを使っているとそうなるだろう。

  • greet/greet.go
package greet

import "mocktest/machine"

type Greet struct {
    m     machine.MachineInterface
    value int32
}

func NewGreet() *Greet {
    g := &Greet{}
    g.m = machine.NewMachineData()
    return g
}

func (g *Greet) GetData() int32 {
    return g.value + g.m.Get()
}

func (g *Greet) SetData(value int32) {
    g.value = value
    g.m.Set(value)
}
  • machine/machine.go
package machine

import (
    "math/rand"
    "time"
)

type MachineInterface interface {
    Get() int32
    Set(value int32)
}

type MachineData struct {
    value int32

    r *rand.Rand
}

func NewMachineData() *MachineData {
    m := &MachineData{}
    m.r = rand.New(rand.NewSource(time.Now().UnixNano()))
    return m
}

func (m *MachineData) Get() int32 {
    multi := m.r.Int31n(100)
    return multi * m.value
}

func (m *MachineData) Set(value int32) {
    m.value = value
}
  • greet/greet_test.go
package greet

import (
    "mocktest/machine"
    "testing"
)

type fakeMachineData struct {
    machine.MachineInterface

    FakeGetData func() int32
    FakeSetData func(value int32)
}

func (f *fakeMachineData) Get() int32 {
    return f.FakeGetData()
}

func (f *fakeMachineData) Set(value int32) {
    f.FakeSetData(value)
}

func TestGetData1(t *testing.T) {
    fakeData := &fakeMachineData{
        FakeGetData: func() int32 {
            return 10
        },
        FakeSetData: func(value int32) {
        },
    }
    mo := NewGreet()
    mo.m = fakeData
    mo.SetData(3)
    value := mo.GetData()
    if value != 13 {
        t.Errorf("GetData: %v", value)
    }
}

func TestGetData2(t *testing.T) {
    fakeData := &fakeMachineData{
        FakeGetData: func() int32 {
            return 15
        },
        FakeSetData: func(value int32) {
        },
    }
    mo := NewGreet()
    mo.m = fakeData
    mo.SetData(5)
    value := mo.GetData()
    if value != 20 {
        t.Errorf("GetData: %v", value)
    }
}

machine を import するようになるくらいの変更しかない。
外部のパッケージだったら interface があっても不自然ではない。

もしここで machine/machine.go に interface がなかったらどうしよう?
その場合は greet/greet.go の方で作っておけば良い。「暗黙的に満足される」から machine/machine.go は変更しなくても良いのだ。
案外、なんとかなるものだ。

  • macihne/machine.go
package machine

import (
    "math/rand"
    "time"
)

// type MachineInterface interface {
//     Get() int32
//     Set(value int32)
// }

type MachineData struct {
    value int32

    r *rand.Rand
}

func NewMachineData() *MachineData {
    m := &MachineData{}
    m.r = rand.New(rand.NewSource(time.Now().UnixNano()))
    return m
}

func (m *MachineData) Get() int32 {
    multi := m.r.Int31n(100)
    return multi * m.value
}

func (m *MachineData) Set(value int32) {
    m.value = value
}
  • greet/greet.go
package greet

import "mocktest/machine"

type MachineInterface interface {
    Get() int32
    Set(value int32)
}

type Greet struct {
    m     MachineInterface
    value int32
}

func NewGreet() *Greet {
    g := &Greet{}
    g.m = machine.NewMachineData()
    return g
}

func (g *Greet) GetData() int32 {
    return g.value + g.m.Get()
}

func (g *Greet) SetData(value int32) {
    g.value = value
    g.m.Set(value)
}
  • greet/greet_test.go
package greet

import (
    "mocktest/machine"
    "testing"
)

type fakeMachineData struct {
    machine.MachineData

    FakeGetData func() int32
    FakeSetData func(value int32)
}

func (f *fakeMachineData) Get() int32 {
    return f.FakeGetData()
}

func (f *fakeMachineData) Set(value int32) {
    f.FakeSetData(value)
}

func TestGetData1(t *testing.T) {
    fakeData := &fakeMachineData{
        FakeGetData: func() int32 {
            return 10
        },
        FakeSetData: func(value int32) {
        },
    }
    mo := NewGreet()
    mo.m = fakeData
    mo.SetData(3)
    value := mo.GetData()
    if value != 13 {
        t.Errorf("GetData: %v", value)
    }
}

func TestGetData2(t *testing.T) {
    fakeData := &fakeMachineData{
        FakeGetData: func() int32 {
            return 15
        },
        FakeSetData: func(value int32) {
        },
    }
    mo := NewGreet()
    mo.m = fakeData
    mo.SetData(5)
    value := mo.GetData()
    if value != 20 {
        t.Errorf("GetData: %v", value)
    }
}