go-translator/pkg/service/features/app.feature

# Во имя Бога Милостивого, Милосердного!!!
# language: ru
Функциональность: Преобразование в C++

  Сценарий: Пустой пакет
    * Исходник:
```
package test
```
    * Результат:
```
void loop() {}
void setup() {}
```

  Сценарий: Пустая структура - класс
    * Исходник:
```
package test

type device struct {}
```
    * Результат:
```
class device {
public:
};
```

  Сценарий: Интерфейс - это класс с виртуальными методами
    * Исходник:
```
package test

type Device interface {
    Name() string
	  String() string
	  Add(int)
	  Add2(int,float64)
}
```
    * Результат:
```
class Device {
public:
  virtual std::string Name() = 0;
  virtual std::string String() = 0;
  virtual void Add(int) = 0;
  virtual void Add2(int,double) = 0;
};
```

  Сценарий: Структура с полем
    * Исходник:
```
package test

type device struct {
  a int
}
```
    * Результат:
```
class device {
public:
  int a;
};
```

  Сценарий: Структура с полями одного типа
    * Исходник:
```
package test

type device struct {
  a,b int
}
```
    * Результат:
```
class device {
public:
  int a,b;
};
```

  Сценарий: Структура с неск полями, строки - std::string
    * Исходник:
```
package test

type device struct {
  a,b int
  c,d,e string
}
```
    * Результат:
```
class device {
public:
  int a,b;
  std::string c,d,e;
};
```

  Сценарий: Структура с методом
    * Исходник:
```
package test

type device struct {
  a int
}

func (d *device) doSomething() {
}
```
    * Результат:
```
class device {
public:
  int a;
  void doSomething();
};
void device::doSomething() {
}
```

  Сценарий: Структура с вызовом метода
    * Исходник:
```
package test

type device struct {
  a int
}

func (d *device) doSomething() {
    d.doSomethingElse()
}
func (d *device) doSomethingElse() {
}
```
    * Результат:
```
class device {
public:
  int a;
  void doSomething();
  void doSomethingElse();
};
void device::doSomething() {
this->doSomethingElse();
}
void device::doSomethingElse() {
}
```

  Сценарий: Структура с вызовом метода другого объекта
    * Исходник:
```
package test

type device struct {
  remote Other
}

func (d *device) doSomething() {
    d.remote.doSomethingElse()
}
```
    * Результат:
```
class device {
public:
  Other remote;
  void doSomething();
};
void device::doSomething() {
this->remote->doSomethingElse();
}
```

  Сценарий: Структура с вызовом методов со входящими и выходящими параметрами
    * Исходник:
```
package test

type device struct {
  a int
}

func (d *device) doSomething(i int, x string) {
    d.doSomethingElse(1, 0.5)
    d.doSomethingElse(i, 0.6)
}
func (d *device) doSomethingElse(i int, f float64) int {
    return 1
}
func (d *device) doSomethingBool(i int, f float64) bool {
    return true
}
```
    * Результат:
```
class device {
public:
  int a;
  void doSomething(int i,std::string x);
  int doSomethingElse(int i,double f);
  bool doSomethingBool(int i,double f);
};
void device::doSomething(int i,std::string x) {
this->doSomethingElse(1,0.5);
this->doSomethingElse(i,0.6);
}
int device::doSomethingElse(int i,double f) {
return 1;
}
bool device::doSomethingBool(int i,double f) {
return true;
}
```

  Сценарий: Структура с изменением свойства
    * Исходник:
```
package test

type device struct {
  x int
  y int
}

func (d *device) doSomething() {
    d.x = 1
    d.x = d.y
}
```
    * Результат:
```
class device {
public:
  int x;
  int y;
  void doSomething();
};
void device::doSomething() {
this->x=1;
this->x=this->y;
}
```

  Сценарий: Структура с вызовом метода и свойства другого объекта
    * Исходник:
```
package test

type device struct {
  x int
}

func (d *device) doSomething() {
    dev2.doSomethingElse()
}
func (d *device) doSomethingElse() {
  dev2.x = 1
  d.x = dev2.x
}
```
    * Результат:
```
class device {
public:
  int x;
  void doSomething();
  void doSomethingElse();
};
void device::doSomething() {
dev2->doSomethingElse();
}
void device::doSomethingElse() {
dev2->x=1;
this->x=dev2->x;
}
```

  Сценарий: Структура с объявлением переменных-указателей и их созданием
    * Исходник:
```
package test

var (
  dev1, dev2 *device
)

type device struct {}

func main() {
  dev1 = &device{}
}
```
    * Результат:
```
class device {
public:
};
void main();
device *dev1,*dev2;
void main() {
dev1=new device();
}
```

  Сценарий: Структура с объявлением переменных-указателей и обычным Go конструктором
    * Исходник:
```
package test

var (
  dev1, dev2 *Device
)

type Device struct {}

func NewDevice() *Device {
  return &Device{}
}

func main() {
  dev1 = NewDevice()
}
```
    * Результат:
```
class Device {
public:
};
Device* NewDevice();
void main();
Device *dev1,*dev2;
Device* NewDevice() {
return new Device();
}
void main() {
dev1=NewDevice();
}
```

  Сценарий: Последовательность блоков: константы, типы, абстрактные классы, классы, переменные, функции
    * Исходник:
```
package test

type Mera int

const c1 = 4
```
    * Результат:
```
const int c1 = 4;
typedef int Mera;
```