Rebase wrapper #332
10
rebase.go
|
|
@ -50,6 +50,15 @@ type Rebase struct {
|
|||
|
|
||||
ptr *C.git_rebase
|
||||
}
|
||||
|
||||
// Abort aborts a rebase that is currently in progress, resetting the repository and working directory to their state before rebase began.
|
||||
This describes the structure mechanically, but almost everything is a wrapper, if we're going to have a comment here, it should describe the object itself and/or what you can do with it. This describes the structure mechanically, but almost everything is a wrapper, if we're going to have a comment here, it should describe the object itself and/or what you can do with it.
We have prior art of naming We have prior art of naming `git_repository_init()` as `InitRepository()` since the namespacing in C and Go is bit different, so this should be called `InitRebase()`.
Like with the init function, this should be called Like with the init function, this should be called `OpenRebase()`. The documentation shouldn't reference the C function `git_rebase_init` but our own.
This return value does not match how Go reports errors. I would expect a This return value does not match how Go reports errors. I would expect a `uint` to return the current operation and an `error` to return any errors.
There is no There is no `GIT_REBASE_OPERATION_EXEC` in git2go, it's `RebaseOperationExec`.
There is no There is no `git_rebase_next` in git2go, we have `Next()`.
Missing space. The pointer isn't public so let's not mention it. "unmanaged resources" covers whatever we decide to put in there. Missing space. The pointer isn't public so let's not mention it. "unmanaged resources" covers whatever we decide to put in there.
The other public id fields are named The other public id fields are named `Id`.
Ok, I followed go convention suggested by my IDE plugin Ok, I followed go convention suggested by my IDE plugin
Done Done
Done Done
Done Done
Done. Done.
I also added `ErrClassRebase` in `git.go`
Hope this is correct
Done Done
Done Done
|
||||
func (rebase *Rebase) Abort() error {
|
||||
|
This describes the structure mechanically, but almost everything is a wrapper, if we're going to have a comment here, it should describe the object itself and/or what you can do with it. This describes the structure mechanically, but almost everything is a wrapper, if we're going to have a comment here, it should describe the object itself and/or what you can do with it.
We have prior art of naming We have prior art of naming `git_repository_init()` as `InitRepository()` since the namespacing in C and Go is bit different, so this should be called `InitRebase()`.
Like with the init function, this should be called Like with the init function, this should be called `OpenRebase()`. The documentation shouldn't reference the C function `git_rebase_init` but our own.
This return value does not match how Go reports errors. I would expect a This return value does not match how Go reports errors. I would expect a `uint` to return the current operation and an `error` to return any errors.
There is no There is no `GIT_REBASE_OPERATION_EXEC` in git2go, it's `RebaseOperationExec`.
There is no There is no `git_rebase_next` in git2go, we have `Next()`.
Missing space. The pointer isn't public so let's not mention it. "unmanaged resources" covers whatever we decide to put in there. Missing space. The pointer isn't public so let's not mention it. "unmanaged resources" covers whatever we decide to put in there.
The other public id fields are named The other public id fields are named `Id`.
Ok, I followed go convention suggested by my IDE plugin Ok, I followed go convention suggested by my IDE plugin
Done Done
Done Done
Done Done
Done. Done.
I also added `ErrClassRebase` in `git.go`
Hope this is correct
Done Done
Done Done
|
||||
err := C.git_rebase_abort(rebase.ptr)
|
||||
|
This describes the structure mechanically, but almost everything is a wrapper, if we're going to have a comment here, it should describe the object itself and/or what you can do with it. This describes the structure mechanically, but almost everything is a wrapper, if we're going to have a comment here, it should describe the object itself and/or what you can do with it.
We have prior art of naming We have prior art of naming `git_repository_init()` as `InitRepository()` since the namespacing in C and Go is bit different, so this should be called `InitRebase()`.
Like with the init function, this should be called Like with the init function, this should be called `OpenRebase()`. The documentation shouldn't reference the C function `git_rebase_init` but our own.
This return value does not match how Go reports errors. I would expect a This return value does not match how Go reports errors. I would expect a `uint` to return the current operation and an `error` to return any errors.
There is no There is no `GIT_REBASE_OPERATION_EXEC` in git2go, it's `RebaseOperationExec`.
There is no There is no `git_rebase_next` in git2go, we have `Next()`.
Missing space. The pointer isn't public so let's not mention it. "unmanaged resources" covers whatever we decide to put in there. Missing space. The pointer isn't public so let's not mention it. "unmanaged resources" covers whatever we decide to put in there.
The other public id fields are named The other public id fields are named `Id`.
Ok, I followed go convention suggested by my IDE plugin Ok, I followed go convention suggested by my IDE plugin
Done Done
Done Done
Done Done
Done. Done.
I also added `ErrClassRebase` in `git.go`
Hope this is correct
Done Done
Done Done
|
||||
if err < 0 {
|
||||
|
This describes the structure mechanically, but almost everything is a wrapper, if we're going to have a comment here, it should describe the object itself and/or what you can do with it. This describes the structure mechanically, but almost everything is a wrapper, if we're going to have a comment here, it should describe the object itself and/or what you can do with it.
We have prior art of naming We have prior art of naming `git_repository_init()` as `InitRepository()` since the namespacing in C and Go is bit different, so this should be called `InitRebase()`.
Like with the init function, this should be called Like with the init function, this should be called `OpenRebase()`. The documentation shouldn't reference the C function `git_rebase_init` but our own.
This return value does not match how Go reports errors. I would expect a This return value does not match how Go reports errors. I would expect a `uint` to return the current operation and an `error` to return any errors.
There is no There is no `GIT_REBASE_OPERATION_EXEC` in git2go, it's `RebaseOperationExec`.
There is no There is no `git_rebase_next` in git2go, we have `Next()`.
Missing space. The pointer isn't public so let's not mention it. "unmanaged resources" covers whatever we decide to put in there. Missing space. The pointer isn't public so let's not mention it. "unmanaged resources" covers whatever we decide to put in there.
The other public id fields are named The other public id fields are named `Id`.
Ok, I followed go convention suggested by my IDE plugin Ok, I followed go convention suggested by my IDE plugin
Done Done
Done Done
Done Done
Done. Done.
I also added `ErrClassRebase` in `git.go`
Hope this is correct
Done Done
Done Done
|
||||
return MakeGitError(err)
|
||||
|
This describes the structure mechanically, but almost everything is a wrapper, if we're going to have a comment here, it should describe the object itself and/or what you can do with it. This describes the structure mechanically, but almost everything is a wrapper, if we're going to have a comment here, it should describe the object itself and/or what you can do with it.
We have prior art of naming We have prior art of naming `git_repository_init()` as `InitRepository()` since the namespacing in C and Go is bit different, so this should be called `InitRebase()`.
Like with the init function, this should be called Like with the init function, this should be called `OpenRebase()`. The documentation shouldn't reference the C function `git_rebase_init` but our own.
This return value does not match how Go reports errors. I would expect a This return value does not match how Go reports errors. I would expect a `uint` to return the current operation and an `error` to return any errors.
There is no There is no `GIT_REBASE_OPERATION_EXEC` in git2go, it's `RebaseOperationExec`.
There is no There is no `git_rebase_next` in git2go, we have `Next()`.
Missing space. The pointer isn't public so let's not mention it. "unmanaged resources" covers whatever we decide to put in there. Missing space. The pointer isn't public so let's not mention it. "unmanaged resources" covers whatever we decide to put in there.
The other public id fields are named The other public id fields are named `Id`.
Ok, I followed go convention suggested by my IDE plugin Ok, I followed go convention suggested by my IDE plugin
Done Done
Done Done
Done Done
Done. Done.
I also added `ErrClassRebase` in `git.go`
Hope this is correct
Done Done
Done Done
|
||||
}
|
||||
|
This describes the structure mechanically, but almost everything is a wrapper, if we're going to have a comment here, it should describe the object itself and/or what you can do with it. This describes the structure mechanically, but almost everything is a wrapper, if we're going to have a comment here, it should describe the object itself and/or what you can do with it.
We have prior art of naming We have prior art of naming `git_repository_init()` as `InitRepository()` since the namespacing in C and Go is bit different, so this should be called `InitRebase()`.
Like with the init function, this should be called Like with the init function, this should be called `OpenRebase()`. The documentation shouldn't reference the C function `git_rebase_init` but our own.
This return value does not match how Go reports errors. I would expect a This return value does not match how Go reports errors. I would expect a `uint` to return the current operation and an `error` to return any errors.
There is no There is no `GIT_REBASE_OPERATION_EXEC` in git2go, it's `RebaseOperationExec`.
There is no There is no `git_rebase_next` in git2go, we have `Next()`.
Missing space. The pointer isn't public so let's not mention it. "unmanaged resources" covers whatever we decide to put in there. Missing space. The pointer isn't public so let's not mention it. "unmanaged resources" covers whatever we decide to put in there.
The other public id fields are named The other public id fields are named `Id`.
Ok, I followed go convention suggested by my IDE plugin Ok, I followed go convention suggested by my IDE plugin
Done Done
Done Done
Done Done
Done. Done.
I also added `ErrClassRebase` in `git.go`
Hope this is correct
Done Done
Done Done
|
||||
return nil
|
||||
|
This describes the structure mechanically, but almost everything is a wrapper, if we're going to have a comment here, it should describe the object itself and/or what you can do with it. This describes the structure mechanically, but almost everything is a wrapper, if we're going to have a comment here, it should describe the object itself and/or what you can do with it.
We have prior art of naming We have prior art of naming `git_repository_init()` as `InitRepository()` since the namespacing in C and Go is bit different, so this should be called `InitRebase()`.
Like with the init function, this should be called Like with the init function, this should be called `OpenRebase()`. The documentation shouldn't reference the C function `git_rebase_init` but our own.
This return value does not match how Go reports errors. I would expect a This return value does not match how Go reports errors. I would expect a `uint` to return the current operation and an `error` to return any errors.
There is no There is no `GIT_REBASE_OPERATION_EXEC` in git2go, it's `RebaseOperationExec`.
There is no There is no `git_rebase_next` in git2go, we have `Next()`.
Missing space. The pointer isn't public so let's not mention it. "unmanaged resources" covers whatever we decide to put in there. Missing space. The pointer isn't public so let's not mention it. "unmanaged resources" covers whatever we decide to put in there.
The other public id fields are named The other public id fields are named `Id`.
Ok, I followed go convention suggested by my IDE plugin Ok, I followed go convention suggested by my IDE plugin
Done Done
Done Done
Done Done
Done. Done.
I also added `ErrClassRebase` in `git.go`
Hope this is correct
Done Done
Done Done
|
||||
}
|
||||
|
This describes the structure mechanically, but almost everything is a wrapper, if we're going to have a comment here, it should describe the object itself and/or what you can do with it. This describes the structure mechanically, but almost everything is a wrapper, if we're going to have a comment here, it should describe the object itself and/or what you can do with it.
We have prior art of naming We have prior art of naming `git_repository_init()` as `InitRepository()` since the namespacing in C and Go is bit different, so this should be called `InitRebase()`.
Like with the init function, this should be called Like with the init function, this should be called `OpenRebase()`. The documentation shouldn't reference the C function `git_rebase_init` but our own.
This return value does not match how Go reports errors. I would expect a This return value does not match how Go reports errors. I would expect a `uint` to return the current operation and an `error` to return any errors.
There is no There is no `GIT_REBASE_OPERATION_EXEC` in git2go, it's `RebaseOperationExec`.
There is no There is no `git_rebase_next` in git2go, we have `Next()`.
Missing space. The pointer isn't public so let's not mention it. "unmanaged resources" covers whatever we decide to put in there. Missing space. The pointer isn't public so let's not mention it. "unmanaged resources" covers whatever we decide to put in there.
The other public id fields are named The other public id fields are named `Id`.
Ok, I followed go convention suggested by my IDE plugin Ok, I followed go convention suggested by my IDE plugin
Done Done
Done Done
Done Done
Done. Done.
I also added `ErrClassRebase` in `git.go`
Hope this is correct
Done Done
Done Done
|
||||
|
||||
|
This describes the structure mechanically, but almost everything is a wrapper, if we're going to have a comment here, it should describe the object itself and/or what you can do with it. This describes the structure mechanically, but almost everything is a wrapper, if we're going to have a comment here, it should describe the object itself and/or what you can do with it.
We have prior art of naming We have prior art of naming `git_repository_init()` as `InitRepository()` since the namespacing in C and Go is bit different, so this should be called `InitRebase()`.
Like with the init function, this should be called Like with the init function, this should be called `OpenRebase()`. The documentation shouldn't reference the C function `git_rebase_init` but our own.
This return value does not match how Go reports errors. I would expect a This return value does not match how Go reports errors. I would expect a `uint` to return the current operation and an `error` to return any errors.
There is no There is no `GIT_REBASE_OPERATION_EXEC` in git2go, it's `RebaseOperationExec`.
There is no There is no `git_rebase_next` in git2go, we have `Next()`.
Missing space. The pointer isn't public so let's not mention it. "unmanaged resources" covers whatever we decide to put in there. Missing space. The pointer isn't public so let's not mention it. "unmanaged resources" covers whatever we decide to put in there.
The other public id fields are named The other public id fields are named `Id`.
Ok, I followed go convention suggested by my IDE plugin Ok, I followed go convention suggested by my IDE plugin
Done Done
Done Done
Done Done
Done. Done.
I also added `ErrClassRebase` in `git.go`
Hope this is correct
Done Done
Done Done
|
||||
//RebaseInit initializes a rebase operation to rebase the changes in branch relative to upstream onto another branch.
|
||||
func (r *Repository) RebaseInit(branch *AnnotatedCommit, upstream *AnnotatedCommit, onto *AnnotatedCommit, opts *RebaseOptions) (*Rebase, error) {
|
||||
runtime.LockOSThread()
|
||||
|
|
@ -158,7 +167,6 @@ func newRebaseFromC(ptr *C.git_rebase) *Rebase {
|
|||
|
This describes the structure mechanically, but almost everything is a wrapper, if we're going to have a comment here, it should describe the object itself and/or what you can do with it. This describes the structure mechanically, but almost everything is a wrapper, if we're going to have a comment here, it should describe the object itself and/or what you can do with it.
This describes the structure mechanically, but almost everything is a wrapper, if we're going to have a comment here, it should describe the object itself and/or what you can do with it. This describes the structure mechanically, but almost everything is a wrapper, if we're going to have a comment here, it should describe the object itself and/or what you can do with it.
We have prior art of naming We have prior art of naming `git_repository_init()` as `InitRepository()` since the namespacing in C and Go is bit different, so this should be called `InitRebase()`.
We have prior art of naming We have prior art of naming `git_repository_init()` as `InitRepository()` since the namespacing in C and Go is bit different, so this should be called `InitRebase()`.
Like with the init function, this should be called Like with the init function, this should be called `OpenRebase()`. The documentation shouldn't reference the C function `git_rebase_init` but our own.
Like with the init function, this should be called Like with the init function, this should be called `OpenRebase()`. The documentation shouldn't reference the C function `git_rebase_init` but our own.
This return value does not match how Go reports errors. I would expect a This return value does not match how Go reports errors. I would expect a `uint` to return the current operation and an `error` to return any errors.
This return value does not match how Go reports errors. I would expect a This return value does not match how Go reports errors. I would expect a `uint` to return the current operation and an `error` to return any errors.
There is no There is no `GIT_REBASE_OPERATION_EXEC` in git2go, it's `RebaseOperationExec`.
There is no There is no `GIT_REBASE_OPERATION_EXEC` in git2go, it's `RebaseOperationExec`.
There is no There is no `git_rebase_next` in git2go, we have `Next()`.
There is no There is no `git_rebase_next` in git2go, we have `Next()`.
Missing space. The pointer isn't public so let's not mention it. "unmanaged resources" covers whatever we decide to put in there. Missing space. The pointer isn't public so let's not mention it. "unmanaged resources" covers whatever we decide to put in there.
Missing space. The pointer isn't public so let's not mention it. "unmanaged resources" covers whatever we decide to put in there. Missing space. The pointer isn't public so let's not mention it. "unmanaged resources" covers whatever we decide to put in there.
The other public id fields are named The other public id fields are named `Id`.
The other public id fields are named The other public id fields are named `Id`.
Ok, I followed go convention suggested by my IDE plugin Ok, I followed go convention suggested by my IDE plugin
Ok, I followed go convention suggested by my IDE plugin Ok, I followed go convention suggested by my IDE plugin
Done Done
Done Done
Done Done
Done Done
Done Done
Done Done
Done. Done.
I also added `ErrClassRebase` in `git.go`
Hope this is correct
Done. Done.
I also added `ErrClassRebase` in `git.go`
Hope this is correct
Done Done
Done Done
Done Done
Done Done
|
||||
|
||||
/* TODO -- Add last wrapper services and manage rebase_options
|
||||
|
||||
int git_rebase_abort(git_rebase *rebase);
|
||||
|
This describes the structure mechanically, but almost everything is a wrapper, if we're going to have a comment here, it should describe the object itself and/or what you can do with it. This describes the structure mechanically, but almost everything is a wrapper, if we're going to have a comment here, it should describe the object itself and/or what you can do with it.
We have prior art of naming We have prior art of naming `git_repository_init()` as `InitRepository()` since the namespacing in C and Go is bit different, so this should be called `InitRebase()`.
Like with the init function, this should be called Like with the init function, this should be called `OpenRebase()`. The documentation shouldn't reference the C function `git_rebase_init` but our own.
This return value does not match how Go reports errors. I would expect a This return value does not match how Go reports errors. I would expect a `uint` to return the current operation and an `error` to return any errors.
There is no There is no `GIT_REBASE_OPERATION_EXEC` in git2go, it's `RebaseOperationExec`.
There is no There is no `git_rebase_next` in git2go, we have `Next()`.
Missing space. The pointer isn't public so let's not mention it. "unmanaged resources" covers whatever we decide to put in there. Missing space. The pointer isn't public so let's not mention it. "unmanaged resources" covers whatever we decide to put in there.
The other public id fields are named The other public id fields are named `Id`.
Ok, I followed go convention suggested by my IDE plugin Ok, I followed go convention suggested by my IDE plugin
Done Done
Done Done
Done Done
Done. Done.
I also added `ErrClassRebase` in `git.go`
Hope this is correct
Done Done
Done Done
|
||||
int git_rebase_init_options(git_rebase_options *opts, unsigned int version);
|
||||
int git_rebase_open(git_rebase **out, git_repository *repo, const git_rebase_options *opts);
|
||||
git_rebase_operation * git_rebase_operation_byindex(git_rebase *rebase, size_t idx);
|
||||
|
|
|
|||
|
This describes the structure mechanically, but almost everything is a wrapper, if we're going to have a comment here, it should describe the object itself and/or what you can do with it. This describes the structure mechanically, but almost everything is a wrapper, if we're going to have a comment here, it should describe the object itself and/or what you can do with it.
This describes the structure mechanically, but almost everything is a wrapper, if we're going to have a comment here, it should describe the object itself and/or what you can do with it. This describes the structure mechanically, but almost everything is a wrapper, if we're going to have a comment here, it should describe the object itself and/or what you can do with it.
We have prior art of naming We have prior art of naming `git_repository_init()` as `InitRepository()` since the namespacing in C and Go is bit different, so this should be called `InitRebase()`.
We have prior art of naming We have prior art of naming `git_repository_init()` as `InitRepository()` since the namespacing in C and Go is bit different, so this should be called `InitRebase()`.
Like with the init function, this should be called Like with the init function, this should be called `OpenRebase()`. The documentation shouldn't reference the C function `git_rebase_init` but our own.
Like with the init function, this should be called Like with the init function, this should be called `OpenRebase()`. The documentation shouldn't reference the C function `git_rebase_init` but our own.
This return value does not match how Go reports errors. I would expect a This return value does not match how Go reports errors. I would expect a `uint` to return the current operation and an `error` to return any errors.
This return value does not match how Go reports errors. I would expect a This return value does not match how Go reports errors. I would expect a `uint` to return the current operation and an `error` to return any errors.
There is no There is no `GIT_REBASE_OPERATION_EXEC` in git2go, it's `RebaseOperationExec`.
There is no There is no `GIT_REBASE_OPERATION_EXEC` in git2go, it's `RebaseOperationExec`.
There is no There is no `git_rebase_next` in git2go, we have `Next()`.
There is no There is no `git_rebase_next` in git2go, we have `Next()`.
Missing space. The pointer isn't public so let's not mention it. "unmanaged resources" covers whatever we decide to put in there. Missing space. The pointer isn't public so let's not mention it. "unmanaged resources" covers whatever we decide to put in there.
Missing space. The pointer isn't public so let's not mention it. "unmanaged resources" covers whatever we decide to put in there. Missing space. The pointer isn't public so let's not mention it. "unmanaged resources" covers whatever we decide to put in there.
The other public id fields are named The other public id fields are named `Id`.
The other public id fields are named The other public id fields are named `Id`.
Ok, I followed go convention suggested by my IDE plugin Ok, I followed go convention suggested by my IDE plugin
Ok, I followed go convention suggested by my IDE plugin Ok, I followed go convention suggested by my IDE plugin
Done Done
Done Done
Done Done
Done Done
Done Done
Done Done
Done. Done.
I also added `ErrClassRebase` in `git.go`
Hope this is correct
Done. Done.
I also added `ErrClassRebase` in `git.go`
Hope this is correct
Done Done
Done Done
Done Done
Done Done
|
||||
|
|
@ -9,6 +9,58 @@ import (
|
|||
|
Don't hard-code 1 here, the point of the version field is to increase it. Don't hard-code 1 here, the point of the version field is to increase it.
Don't hard-code 1 here, the point of the version field is to increase it. Don't hard-code 1 here, the point of the version field is to increase it.
Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a `#define` or a constant that was used as default version number.
The test doesn't have great value though
Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a `#define` or a constant that was used as default version number.
The test doesn't have great value though
The version it needs to return in the version that is specified by the libgit2 headers in the The version it needs to return in the version that is specified by the libgit2 headers in the `#define`. That's what the compiler is building and that's what it will use in order to figure out the size of the struct, which has to match what we're telling libgit2 we have.
The version it needs to return in the version that is specified by the libgit2 headers in the The version it needs to return in the version that is specified by the libgit2 headers in the `#define`. That's what the compiler is building and that's what it will use in order to figure out the size of the struct, which has to match what we're telling libgit2 we have.
Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think. Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think.
Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think. Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think.
|
||||
|
||||
// Tests
|
||||
|
||||
func TestRebaseAbort(t *testing.T) {
|
||||
|
Don't hard-code 1 here, the point of the version field is to increase it. Don't hard-code 1 here, the point of the version field is to increase it.
Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a `#define` or a constant that was used as default version number.
The test doesn't have great value though
The version it needs to return in the version that is specified by the libgit2 headers in the The version it needs to return in the version that is specified by the libgit2 headers in the `#define`. That's what the compiler is building and that's what it will use in order to figure out the size of the struct, which has to match what we're telling libgit2 we have.
Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think. Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think.
|
||||
// TEST DATA
|
||||
|
Don't hard-code 1 here, the point of the version field is to increase it. Don't hard-code 1 here, the point of the version field is to increase it.
Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a `#define` or a constant that was used as default version number.
The test doesn't have great value though
The version it needs to return in the version that is specified by the libgit2 headers in the The version it needs to return in the version that is specified by the libgit2 headers in the `#define`. That's what the compiler is building and that's what it will use in order to figure out the size of the struct, which has to match what we're telling libgit2 we have.
Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think. Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think.
|
||||
|
||||
|
Don't hard-code 1 here, the point of the version field is to increase it. Don't hard-code 1 here, the point of the version field is to increase it.
Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a `#define` or a constant that was used as default version number.
The test doesn't have great value though
The version it needs to return in the version that is specified by the libgit2 headers in the The version it needs to return in the version that is specified by the libgit2 headers in the `#define`. That's what the compiler is building and that's what it will use in order to figure out the size of the struct, which has to match what we're telling libgit2 we have.
Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think. Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think.
|
||||
// Inputs
|
||||
|
Don't hard-code 1 here, the point of the version field is to increase it. Don't hard-code 1 here, the point of the version field is to increase it.
Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a `#define` or a constant that was used as default version number.
The test doesn't have great value though
The version it needs to return in the version that is specified by the libgit2 headers in the The version it needs to return in the version that is specified by the libgit2 headers in the `#define`. That's what the compiler is building and that's what it will use in order to figure out the size of the struct, which has to match what we're telling libgit2 we have.
Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think. Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think.
|
||||
branchName := "emile"
|
||||
|
Don't hard-code 1 here, the point of the version field is to increase it. Don't hard-code 1 here, the point of the version field is to increase it.
Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a `#define` or a constant that was used as default version number.
The test doesn't have great value though
The version it needs to return in the version that is specified by the libgit2 headers in the The version it needs to return in the version that is specified by the libgit2 headers in the `#define`. That's what the compiler is building and that's what it will use in order to figure out the size of the struct, which has to match what we're telling libgit2 we have.
Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think. Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think.
|
||||
masterCommit := "something"
|
||||
|
Don't hard-code 1 here, the point of the version field is to increase it. Don't hard-code 1 here, the point of the version field is to increase it.
Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a `#define` or a constant that was used as default version number.
The test doesn't have great value though
The version it needs to return in the version that is specified by the libgit2 headers in the The version it needs to return in the version that is specified by the libgit2 headers in the `#define`. That's what the compiler is building and that's what it will use in order to figure out the size of the struct, which has to match what we're telling libgit2 we have.
Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think. Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think.
|
||||
emileCommits := []string{
|
||||
|
Don't hard-code 1 here, the point of the version field is to increase it. Don't hard-code 1 here, the point of the version field is to increase it.
Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a `#define` or a constant that was used as default version number.
The test doesn't have great value though
The version it needs to return in the version that is specified by the libgit2 headers in the The version it needs to return in the version that is specified by the libgit2 headers in the `#define`. That's what the compiler is building and that's what it will use in order to figure out the size of the struct, which has to match what we're telling libgit2 we have.
Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think. Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think.
|
||||
"fou",
|
||||
|
Don't hard-code 1 here, the point of the version field is to increase it. Don't hard-code 1 here, the point of the version field is to increase it.
Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a `#define` or a constant that was used as default version number.
The test doesn't have great value though
The version it needs to return in the version that is specified by the libgit2 headers in the The version it needs to return in the version that is specified by the libgit2 headers in the `#define`. That's what the compiler is building and that's what it will use in order to figure out the size of the struct, which has to match what we're telling libgit2 we have.
Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think. Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think.
|
||||
"barre",
|
||||
|
Don't hard-code 1 here, the point of the version field is to increase it. Don't hard-code 1 here, the point of the version field is to increase it.
Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a `#define` or a constant that was used as default version number.
The test doesn't have great value though
The version it needs to return in the version that is specified by the libgit2 headers in the The version it needs to return in the version that is specified by the libgit2 headers in the `#define`. That's what the compiler is building and that's what it will use in order to figure out the size of the struct, which has to match what we're telling libgit2 we have.
Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think. Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think.
|
||||
}
|
||||
|
Don't hard-code 1 here, the point of the version field is to increase it. Don't hard-code 1 here, the point of the version field is to increase it.
Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a `#define` or a constant that was used as default version number.
The test doesn't have great value though
The version it needs to return in the version that is specified by the libgit2 headers in the The version it needs to return in the version that is specified by the libgit2 headers in the `#define`. That's what the compiler is building and that's what it will use in order to figure out the size of the struct, which has to match what we're telling libgit2 we have.
Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think. Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think.
|
||||
|
||||
|
Don't hard-code 1 here, the point of the version field is to increase it. Don't hard-code 1 here, the point of the version field is to increase it.
Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a `#define` or a constant that was used as default version number.
The test doesn't have great value though
The version it needs to return in the version that is specified by the libgit2 headers in the The version it needs to return in the version that is specified by the libgit2 headers in the `#define`. That's what the compiler is building and that's what it will use in order to figure out the size of the struct, which has to match what we're telling libgit2 we have.
Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think. Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think.
|
||||
// Outputs
|
||||
|
Don't hard-code 1 here, the point of the version field is to increase it. Don't hard-code 1 here, the point of the version field is to increase it.
Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a `#define` or a constant that was used as default version number.
The test doesn't have great value though
The version it needs to return in the version that is specified by the libgit2 headers in the The version it needs to return in the version that is specified by the libgit2 headers in the `#define`. That's what the compiler is building and that's what it will use in order to figure out the size of the struct, which has to match what we're telling libgit2 we have.
Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think. Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think.
|
||||
expectedHistory := []string{
|
||||
|
Don't hard-code 1 here, the point of the version field is to increase it. Don't hard-code 1 here, the point of the version field is to increase it.
Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a `#define` or a constant that was used as default version number.
The test doesn't have great value though
The version it needs to return in the version that is specified by the libgit2 headers in the The version it needs to return in the version that is specified by the libgit2 headers in the `#define`. That's what the compiler is building and that's what it will use in order to figure out the size of the struct, which has to match what we're telling libgit2 we have.
Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think. Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think.
|
||||
"Test rebase, Baby! " + emileCommits[1],
|
||||
|
Don't hard-code 1 here, the point of the version field is to increase it. Don't hard-code 1 here, the point of the version field is to increase it.
Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a `#define` or a constant that was used as default version number.
The test doesn't have great value though
The version it needs to return in the version that is specified by the libgit2 headers in the The version it needs to return in the version that is specified by the libgit2 headers in the `#define`. That's what the compiler is building and that's what it will use in order to figure out the size of the struct, which has to match what we're telling libgit2 we have.
Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think. Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think.
|
||||
"Test rebase, Baby! " + emileCommits[0],
|
||||
|
Don't hard-code 1 here, the point of the version field is to increase it. Don't hard-code 1 here, the point of the version field is to increase it.
Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a `#define` or a constant that was used as default version number.
The test doesn't have great value though
The version it needs to return in the version that is specified by the libgit2 headers in the The version it needs to return in the version that is specified by the libgit2 headers in the `#define`. That's what the compiler is building and that's what it will use in order to figure out the size of the struct, which has to match what we're telling libgit2 we have.
Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think. Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think.
|
||||
"This is a commit\n",
|
||||
|
Don't hard-code 1 here, the point of the version field is to increase it. Don't hard-code 1 here, the point of the version field is to increase it.
Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a `#define` or a constant that was used as default version number.
The test doesn't have great value though
The version it needs to return in the version that is specified by the libgit2 headers in the The version it needs to return in the version that is specified by the libgit2 headers in the `#define`. That's what the compiler is building and that's what it will use in order to figure out the size of the struct, which has to match what we're telling libgit2 we have.
Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think. Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think.
|
||||
}
|
||||
|
Don't hard-code 1 here, the point of the version field is to increase it. Don't hard-code 1 here, the point of the version field is to increase it.
Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a `#define` or a constant that was used as default version number.
The test doesn't have great value though
The version it needs to return in the version that is specified by the libgit2 headers in the The version it needs to return in the version that is specified by the libgit2 headers in the `#define`. That's what the compiler is building and that's what it will use in order to figure out the size of the struct, which has to match what we're telling libgit2 we have.
Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think. Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think.
|
||||
|
||||
|
Don't hard-code 1 here, the point of the version field is to increase it. Don't hard-code 1 here, the point of the version field is to increase it.
Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a `#define` or a constant that was used as default version number.
The test doesn't have great value though
The version it needs to return in the version that is specified by the libgit2 headers in the The version it needs to return in the version that is specified by the libgit2 headers in the `#define`. That's what the compiler is building and that's what it will use in order to figure out the size of the struct, which has to match what we're telling libgit2 we have.
Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think. Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think.
|
||||
// TEST
|
||||
|
Don't hard-code 1 here, the point of the version field is to increase it. Don't hard-code 1 here, the point of the version field is to increase it.
Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a `#define` or a constant that was used as default version number.
The test doesn't have great value though
The version it needs to return in the version that is specified by the libgit2 headers in the The version it needs to return in the version that is specified by the libgit2 headers in the `#define`. That's what the compiler is building and that's what it will use in order to figure out the size of the struct, which has to match what we're telling libgit2 we have.
Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think. Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think.
|
||||
repo := createTestRepo(t)
|
||||
|
Don't hard-code 1 here, the point of the version field is to increase it. Don't hard-code 1 here, the point of the version field is to increase it.
Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a `#define` or a constant that was used as default version number.
The test doesn't have great value though
The version it needs to return in the version that is specified by the libgit2 headers in the The version it needs to return in the version that is specified by the libgit2 headers in the `#define`. That's what the compiler is building and that's what it will use in order to figure out the size of the struct, which has to match what we're telling libgit2 we have.
Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think. Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think.
|
||||
seedTestRepo(t, repo)
|
||||
|
Don't hard-code 1 here, the point of the version field is to increase it. Don't hard-code 1 here, the point of the version field is to increase it.
Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a `#define` or a constant that was used as default version number.
The test doesn't have great value though
The version it needs to return in the version that is specified by the libgit2 headers in the The version it needs to return in the version that is specified by the libgit2 headers in the `#define`. That's what the compiler is building and that's what it will use in order to figure out the size of the struct, which has to match what we're telling libgit2 we have.
Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think. Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think.
|
||||
|
||||
|
Don't hard-code 1 here, the point of the version field is to increase it. Don't hard-code 1 here, the point of the version field is to increase it.
Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a `#define` or a constant that was used as default version number.
The test doesn't have great value though
The version it needs to return in the version that is specified by the libgit2 headers in the The version it needs to return in the version that is specified by the libgit2 headers in the `#define`. That's what the compiler is building and that's what it will use in order to figure out the size of the struct, which has to match what we're telling libgit2 we have.
Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think. Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think.
|
||||
// Setup a repo with 2 branches and a different tree
|
||||
|
Don't hard-code 1 here, the point of the version field is to increase it. Don't hard-code 1 here, the point of the version field is to increase it.
Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a `#define` or a constant that was used as default version number.
The test doesn't have great value though
The version it needs to return in the version that is specified by the libgit2 headers in the The version it needs to return in the version that is specified by the libgit2 headers in the `#define`. That's what the compiler is building and that's what it will use in order to figure out the size of the struct, which has to match what we're telling libgit2 we have.
Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think. Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think.
|
||||
err := setupRepoForRebase(repo, masterCommit, branchName)
|
||||
|
Don't hard-code 1 here, the point of the version field is to increase it. Don't hard-code 1 here, the point of the version field is to increase it.
Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a `#define` or a constant that was used as default version number.
The test doesn't have great value though
The version it needs to return in the version that is specified by the libgit2 headers in the The version it needs to return in the version that is specified by the libgit2 headers in the `#define`. That's what the compiler is building and that's what it will use in order to figure out the size of the struct, which has to match what we're telling libgit2 we have.
Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think. Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think.
|
||||
checkFatal(t, err)
|
||||
|
Don't hard-code 1 here, the point of the version field is to increase it. Don't hard-code 1 here, the point of the version field is to increase it.
Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a `#define` or a constant that was used as default version number.
The test doesn't have great value though
The version it needs to return in the version that is specified by the libgit2 headers in the The version it needs to return in the version that is specified by the libgit2 headers in the `#define`. That's what the compiler is building and that's what it will use in order to figure out the size of the struct, which has to match what we're telling libgit2 we have.
Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think. Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think.
|
||||
defer cleanupTestRepo(t, repo)
|
||||
|
Don't hard-code 1 here, the point of the version field is to increase it. Don't hard-code 1 here, the point of the version field is to increase it.
Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a `#define` or a constant that was used as default version number.
The test doesn't have great value though
The version it needs to return in the version that is specified by the libgit2 headers in the The version it needs to return in the version that is specified by the libgit2 headers in the `#define`. That's what the compiler is building and that's what it will use in order to figure out the size of the struct, which has to match what we're telling libgit2 we have.
Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think. Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think.
|
||||
|
||||
|
Don't hard-code 1 here, the point of the version field is to increase it. Don't hard-code 1 here, the point of the version field is to increase it.
Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a `#define` or a constant that was used as default version number.
The test doesn't have great value though
The version it needs to return in the version that is specified by the libgit2 headers in the The version it needs to return in the version that is specified by the libgit2 headers in the `#define`. That's what the compiler is building and that's what it will use in order to figure out the size of the struct, which has to match what we're telling libgit2 we have.
Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think. Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think.
|
||||
// Create several commits in emile
|
||||
|
Don't hard-code 1 here, the point of the version field is to increase it. Don't hard-code 1 here, the point of the version field is to increase it.
Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a `#define` or a constant that was used as default version number.
The test doesn't have great value though
The version it needs to return in the version that is specified by the libgit2 headers in the The version it needs to return in the version that is specified by the libgit2 headers in the `#define`. That's what the compiler is building and that's what it will use in order to figure out the size of the struct, which has to match what we're telling libgit2 we have.
Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think. Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think.
|
||||
for _, commit := range emileCommits {
|
||||
|
Don't hard-code 1 here, the point of the version field is to increase it. Don't hard-code 1 here, the point of the version field is to increase it.
Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a `#define` or a constant that was used as default version number.
The test doesn't have great value though
The version it needs to return in the version that is specified by the libgit2 headers in the The version it needs to return in the version that is specified by the libgit2 headers in the `#define`. That's what the compiler is building and that's what it will use in order to figure out the size of the struct, which has to match what we're telling libgit2 we have.
Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think. Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think.
|
||||
_, err = commitSomething(repo, commit, commit)
|
||||
|
Don't hard-code 1 here, the point of the version field is to increase it. Don't hard-code 1 here, the point of the version field is to increase it.
Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a `#define` or a constant that was used as default version number.
The test doesn't have great value though
The version it needs to return in the version that is specified by the libgit2 headers in the The version it needs to return in the version that is specified by the libgit2 headers in the `#define`. That's what the compiler is building and that's what it will use in order to figure out the size of the struct, which has to match what we're telling libgit2 we have.
Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think. Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think.
|
||||
checkFatal(t, err)
|
||||
|
Don't hard-code 1 here, the point of the version field is to increase it. Don't hard-code 1 here, the point of the version field is to increase it.
Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a `#define` or a constant that was used as default version number.
The test doesn't have great value though
The version it needs to return in the version that is specified by the libgit2 headers in the The version it needs to return in the version that is specified by the libgit2 headers in the `#define`. That's what the compiler is building and that's what it will use in order to figure out the size of the struct, which has to match what we're telling libgit2 we have.
Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think. Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think.
|
||||
}
|
||||
|
Don't hard-code 1 here, the point of the version field is to increase it. Don't hard-code 1 here, the point of the version field is to increase it.
Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a `#define` or a constant that was used as default version number.
The test doesn't have great value though
The version it needs to return in the version that is specified by the libgit2 headers in the The version it needs to return in the version that is specified by the libgit2 headers in the `#define`. That's what the compiler is building and that's what it will use in order to figure out the size of the struct, which has to match what we're telling libgit2 we have.
Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think. Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think.
|
||||
|
||||
|
Don't hard-code 1 here, the point of the version field is to increase it. Don't hard-code 1 here, the point of the version field is to increase it.
Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a `#define` or a constant that was used as default version number.
The test doesn't have great value though
The version it needs to return in the version that is specified by the libgit2 headers in the The version it needs to return in the version that is specified by the libgit2 headers in the `#define`. That's what the compiler is building and that's what it will use in order to figure out the size of the struct, which has to match what we're telling libgit2 we have.
Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think. Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think.
|
||||
// Check history
|
||||
|
Don't hard-code 1 here, the point of the version field is to increase it. Don't hard-code 1 here, the point of the version field is to increase it.
Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a `#define` or a constant that was used as default version number.
The test doesn't have great value though
The version it needs to return in the version that is specified by the libgit2 headers in the The version it needs to return in the version that is specified by the libgit2 headers in the `#define`. That's what the compiler is building and that's what it will use in order to figure out the size of the struct, which has to match what we're telling libgit2 we have.
Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think. Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think.
|
||||
actualHistory, err := commitMsgsList(repo)
|
||||
|
Don't hard-code 1 here, the point of the version field is to increase it. Don't hard-code 1 here, the point of the version field is to increase it.
Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a `#define` or a constant that was used as default version number.
The test doesn't have great value though
The version it needs to return in the version that is specified by the libgit2 headers in the The version it needs to return in the version that is specified by the libgit2 headers in the `#define`. That's what the compiler is building and that's what it will use in order to figure out the size of the struct, which has to match what we're telling libgit2 we have.
Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think. Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think.
|
||||
checkFatal(t, err)
|
||||
|
Don't hard-code 1 here, the point of the version field is to increase it. Don't hard-code 1 here, the point of the version field is to increase it.
Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a `#define` or a constant that was used as default version number.
The test doesn't have great value though
The version it needs to return in the version that is specified by the libgit2 headers in the The version it needs to return in the version that is specified by the libgit2 headers in the `#define`. That's what the compiler is building and that's what it will use in order to figure out the size of the struct, which has to match what we're telling libgit2 we have.
Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think. Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think.
|
||||
assertStringList(t, expectedHistory, actualHistory)
|
||||
|
Don't hard-code 1 here, the point of the version field is to increase it. Don't hard-code 1 here, the point of the version field is to increase it.
Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a `#define` or a constant that was used as default version number.
The test doesn't have great value though
The version it needs to return in the version that is specified by the libgit2 headers in the The version it needs to return in the version that is specified by the libgit2 headers in the `#define`. That's what the compiler is building and that's what it will use in order to figure out the size of the struct, which has to match what we're telling libgit2 we have.
Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think. Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think.
|
||||
|
||||
|
Don't hard-code 1 here, the point of the version field is to increase it. Don't hard-code 1 here, the point of the version field is to increase it.
Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a `#define` or a constant that was used as default version number.
The test doesn't have great value though
The version it needs to return in the version that is specified by the libgit2 headers in the The version it needs to return in the version that is specified by the libgit2 headers in the `#define`. That's what the compiler is building and that's what it will use in order to figure out the size of the struct, which has to match what we're telling libgit2 we have.
Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think. Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think.
|
||||
// Rebase onto master
|
||||
|
Don't hard-code 1 here, the point of the version field is to increase it. Don't hard-code 1 here, the point of the version field is to increase it.
Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a `#define` or a constant that was used as default version number.
The test doesn't have great value though
The version it needs to return in the version that is specified by the libgit2 headers in the The version it needs to return in the version that is specified by the libgit2 headers in the `#define`. That's what the compiler is building and that's what it will use in order to figure out the size of the struct, which has to match what we're telling libgit2 we have.
Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think. Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think.
|
||||
rebase, err := performRebaseOnto(repo, "master")
|
||||
|
Don't hard-code 1 here, the point of the version field is to increase it. Don't hard-code 1 here, the point of the version field is to increase it.
Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a `#define` or a constant that was used as default version number.
The test doesn't have great value though
The version it needs to return in the version that is specified by the libgit2 headers in the The version it needs to return in the version that is specified by the libgit2 headers in the `#define`. That's what the compiler is building and that's what it will use in order to figure out the size of the struct, which has to match what we're telling libgit2 we have.
Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think. Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think.
|
||||
checkFatal(t, err)
|
||||
|
Don't hard-code 1 here, the point of the version field is to increase it. Don't hard-code 1 here, the point of the version field is to increase it.
Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a `#define` or a constant that was used as default version number.
The test doesn't have great value though
The version it needs to return in the version that is specified by the libgit2 headers in the The version it needs to return in the version that is specified by the libgit2 headers in the `#define`. That's what the compiler is building and that's what it will use in order to figure out the size of the struct, which has to match what we're telling libgit2 we have.
Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think. Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think.
|
||||
defer rebase.Free()
|
||||
|
Don't hard-code 1 here, the point of the version field is to increase it. Don't hard-code 1 here, the point of the version field is to increase it.
Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a `#define` or a constant that was used as default version number.
The test doesn't have great value though
The version it needs to return in the version that is specified by the libgit2 headers in the The version it needs to return in the version that is specified by the libgit2 headers in the `#define`. That's what the compiler is building and that's what it will use in order to figure out the size of the struct, which has to match what we're telling libgit2 we have.
Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think. Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think.
|
||||
|
||||
|
Don't hard-code 1 here, the point of the version field is to increase it. Don't hard-code 1 here, the point of the version field is to increase it.
Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a `#define` or a constant that was used as default version number.
The test doesn't have great value though
The version it needs to return in the version that is specified by the libgit2 headers in the The version it needs to return in the version that is specified by the libgit2 headers in the `#define`. That's what the compiler is building and that's what it will use in order to figure out the size of the struct, which has to match what we're telling libgit2 we have.
Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think. Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think.
|
||||
// Abort rebase
|
||||
|
Don't hard-code 1 here, the point of the version field is to increase it. Don't hard-code 1 here, the point of the version field is to increase it.
Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a `#define` or a constant that was used as default version number.
The test doesn't have great value though
The version it needs to return in the version that is specified by the libgit2 headers in the The version it needs to return in the version that is specified by the libgit2 headers in the `#define`. That's what the compiler is building and that's what it will use in order to figure out the size of the struct, which has to match what we're telling libgit2 we have.
Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think. Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think.
|
||||
rebase.Abort()
|
||||
|
Don't hard-code 1 here, the point of the version field is to increase it. Don't hard-code 1 here, the point of the version field is to increase it.
Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a `#define` or a constant that was used as default version number.
The test doesn't have great value though
The version it needs to return in the version that is specified by the libgit2 headers in the The version it needs to return in the version that is specified by the libgit2 headers in the `#define`. That's what the compiler is building and that's what it will use in order to figure out the size of the struct, which has to match what we're telling libgit2 we have.
Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think. Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think.
|
||||
|
||||
|
Don't hard-code 1 here, the point of the version field is to increase it. Don't hard-code 1 here, the point of the version field is to increase it.
Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a `#define` or a constant that was used as default version number.
The test doesn't have great value though
The version it needs to return in the version that is specified by the libgit2 headers in the The version it needs to return in the version that is specified by the libgit2 headers in the `#define`. That's what the compiler is building and that's what it will use in order to figure out the size of the struct, which has to match what we're telling libgit2 we have.
Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think. Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think.
|
||||
// Check history is still the same
|
||||
|
Don't hard-code 1 here, the point of the version field is to increase it. Don't hard-code 1 here, the point of the version field is to increase it.
Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a `#define` or a constant that was used as default version number.
The test doesn't have great value though
The version it needs to return in the version that is specified by the libgit2 headers in the The version it needs to return in the version that is specified by the libgit2 headers in the `#define`. That's what the compiler is building and that's what it will use in order to figure out the size of the struct, which has to match what we're telling libgit2 we have.
Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think. Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think.
|
||||
actualHistory, err = commitMsgsList(repo)
|
||||
|
Don't hard-code 1 here, the point of the version field is to increase it. Don't hard-code 1 here, the point of the version field is to increase it.
Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a `#define` or a constant that was used as default version number.
The test doesn't have great value though
The version it needs to return in the version that is specified by the libgit2 headers in the The version it needs to return in the version that is specified by the libgit2 headers in the `#define`. That's what the compiler is building and that's what it will use in order to figure out the size of the struct, which has to match what we're telling libgit2 we have.
Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think. Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think.
|
||||
checkFatal(t, err)
|
||||
|
Don't hard-code 1 here, the point of the version field is to increase it. Don't hard-code 1 here, the point of the version field is to increase it.
Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a `#define` or a constant that was used as default version number.
The test doesn't have great value though
The version it needs to return in the version that is specified by the libgit2 headers in the The version it needs to return in the version that is specified by the libgit2 headers in the `#define`. That's what the compiler is building and that's what it will use in order to figure out the size of the struct, which has to match what we're telling libgit2 we have.
Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think. Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think.
|
||||
assertStringList(t, expectedHistory, actualHistory)
|
||||
|
Don't hard-code 1 here, the point of the version field is to increase it. Don't hard-code 1 here, the point of the version field is to increase it.
Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a `#define` or a constant that was used as default version number.
The test doesn't have great value though
The version it needs to return in the version that is specified by the libgit2 headers in the The version it needs to return in the version that is specified by the libgit2 headers in the `#define`. That's what the compiler is building and that's what it will use in order to figure out the size of the struct, which has to match what we're telling libgit2 we have.
Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think. Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think.
|
||||
}
|
||||
|
Don't hard-code 1 here, the point of the version field is to increase it. Don't hard-code 1 here, the point of the version field is to increase it.
Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a `#define` or a constant that was used as default version number.
The test doesn't have great value though
The version it needs to return in the version that is specified by the libgit2 headers in the The version it needs to return in the version that is specified by the libgit2 headers in the `#define`. That's what the compiler is building and that's what it will use in order to figure out the size of the struct, which has to match what we're telling libgit2 we have.
Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think. Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think.
|
||||
|
||||
|
Don't hard-code 1 here, the point of the version field is to increase it. Don't hard-code 1 here, the point of the version field is to increase it.
Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a `#define` or a constant that was used as default version number.
The test doesn't have great value though
The version it needs to return in the version that is specified by the libgit2 headers in the The version it needs to return in the version that is specified by the libgit2 headers in the `#define`. That's what the compiler is building and that's what it will use in order to figure out the size of the struct, which has to match what we're telling libgit2 we have.
Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think. Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think.
|
||||
func TestRebaseNoConflicts(t *testing.T) {
|
||||
// TEST DATA
|
||||
|
||||
|
|
@ -23,10 +75,10 @@ func TestRebaseNoConflicts(t *testing.T) {
|
|||
|
Don't hard-code 1 here, the point of the version field is to increase it. Don't hard-code 1 here, the point of the version field is to increase it.
Don't hard-code 1 here, the point of the version field is to increase it. Don't hard-code 1 here, the point of the version field is to increase it.
Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a `#define` or a constant that was used as default version number.
The test doesn't have great value though
Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a `#define` or a constant that was used as default version number.
The test doesn't have great value though
The version it needs to return in the version that is specified by the libgit2 headers in the The version it needs to return in the version that is specified by the libgit2 headers in the `#define`. That's what the compiler is building and that's what it will use in order to figure out the size of the struct, which has to match what we're telling libgit2 we have.
The version it needs to return in the version that is specified by the libgit2 headers in the The version it needs to return in the version that is specified by the libgit2 headers in the `#define`. That's what the compiler is building and that's what it will use in order to figure out the size of the struct, which has to match what we're telling libgit2 we have.
Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think. Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think.
Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think. Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think.
|
||||
|
||||
// Outputs
|
||||
expectedHistory := []string{
|
||||
"Test rebase onto, Baby! " + emileCommits[2],
|
||||
|
Don't hard-code 1 here, the point of the version field is to increase it. Don't hard-code 1 here, the point of the version field is to increase it.
Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a `#define` or a constant that was used as default version number.
The test doesn't have great value though
The version it needs to return in the version that is specified by the libgit2 headers in the The version it needs to return in the version that is specified by the libgit2 headers in the `#define`. That's what the compiler is building and that's what it will use in order to figure out the size of the struct, which has to match what we're telling libgit2 we have.
Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think. Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think.
|
||||
"Test rebase onto, Baby! " + emileCommits[1],
|
||||
|
Don't hard-code 1 here, the point of the version field is to increase it. Don't hard-code 1 here, the point of the version field is to increase it.
Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a `#define` or a constant that was used as default version number.
The test doesn't have great value though
The version it needs to return in the version that is specified by the libgit2 headers in the The version it needs to return in the version that is specified by the libgit2 headers in the `#define`. That's what the compiler is building and that's what it will use in order to figure out the size of the struct, which has to match what we're telling libgit2 we have.
Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think. Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think.
|
||||
"Test rebase onto, Baby! " + emileCommits[0],
|
||||
|
Don't hard-code 1 here, the point of the version field is to increase it. Don't hard-code 1 here, the point of the version field is to increase it.
Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a `#define` or a constant that was used as default version number.
The test doesn't have great value though
The version it needs to return in the version that is specified by the libgit2 headers in the The version it needs to return in the version that is specified by the libgit2 headers in the `#define`. That's what the compiler is building and that's what it will use in order to figure out the size of the struct, which has to match what we're telling libgit2 we have.
Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think. Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think.
|
||||
"Test rebase onto, Baby! " + masterCommit,
|
||||
|
Don't hard-code 1 here, the point of the version field is to increase it. Don't hard-code 1 here, the point of the version field is to increase it.
Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a `#define` or a constant that was used as default version number.
The test doesn't have great value though
The version it needs to return in the version that is specified by the libgit2 headers in the The version it needs to return in the version that is specified by the libgit2 headers in the `#define`. That's what the compiler is building and that's what it will use in order to figure out the size of the struct, which has to match what we're telling libgit2 we have.
Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think. Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think.
|
||||
"Test rebase, Baby! " + emileCommits[2],
|
||||
|
Don't hard-code 1 here, the point of the version field is to increase it. Don't hard-code 1 here, the point of the version field is to increase it.
Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a `#define` or a constant that was used as default version number.
The test doesn't have great value though
The version it needs to return in the version that is specified by the libgit2 headers in the The version it needs to return in the version that is specified by the libgit2 headers in the `#define`. That's what the compiler is building and that's what it will use in order to figure out the size of the struct, which has to match what we're telling libgit2 we have.
Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think. Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think.
|
||||
"Test rebase, Baby! " + emileCommits[1],
|
||||
|
Don't hard-code 1 here, the point of the version field is to increase it. Don't hard-code 1 here, the point of the version field is to increase it.
Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a `#define` or a constant that was used as default version number.
The test doesn't have great value though
The version it needs to return in the version that is specified by the libgit2 headers in the The version it needs to return in the version that is specified by the libgit2 headers in the `#define`. That's what the compiler is building and that's what it will use in order to figure out the size of the struct, which has to match what we're telling libgit2 we have.
Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think. Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think.
|
||||
"Test rebase, Baby! " + emileCommits[0],
|
||||
|
Don't hard-code 1 here, the point of the version field is to increase it. Don't hard-code 1 here, the point of the version field is to increase it.
Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a `#define` or a constant that was used as default version number.
The test doesn't have great value though
The version it needs to return in the version that is specified by the libgit2 headers in the The version it needs to return in the version that is specified by the libgit2 headers in the `#define`. That's what the compiler is building and that's what it will use in order to figure out the size of the struct, which has to match what we're telling libgit2 we have.
Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think. Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think.
|
||||
"Test rebase, Baby! " + masterCommit,
|
||||
|
Don't hard-code 1 here, the point of the version field is to increase it. Don't hard-code 1 here, the point of the version field is to increase it.
Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a `#define` or a constant that was used as default version number.
The test doesn't have great value though
The version it needs to return in the version that is specified by the libgit2 headers in the The version it needs to return in the version that is specified by the libgit2 headers in the `#define`. That's what the compiler is building and that's what it will use in order to figure out the size of the struct, which has to match what we're telling libgit2 we have.
Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think. Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think.
|
||||
"This is a commit\n",
|
||||
}
|
||||
|
||||
|
|
@ -46,7 +98,12 @@ func TestRebaseNoConflicts(t *testing.T) {
|
|||
|
Don't hard-code 1 here, the point of the version field is to increase it. Don't hard-code 1 here, the point of the version field is to increase it.
Don't hard-code 1 here, the point of the version field is to increase it. Don't hard-code 1 here, the point of the version field is to increase it.
Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a `#define` or a constant that was used as default version number.
The test doesn't have great value though
Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a `#define` or a constant that was used as default version number.
The test doesn't have great value though
The version it needs to return in the version that is specified by the libgit2 headers in the The version it needs to return in the version that is specified by the libgit2 headers in the `#define`. That's what the compiler is building and that's what it will use in order to figure out the size of the struct, which has to match what we're telling libgit2 we have.
The version it needs to return in the version that is specified by the libgit2 headers in the The version it needs to return in the version that is specified by the libgit2 headers in the `#define`. That's what the compiler is building and that's what it will use in order to figure out the size of the struct, which has to match what we're telling libgit2 we have.
Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think. Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think.
Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think. Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think.
|
||||
}
|
||||
|
||||
// Rebase onto master
|
||||
err = performRebaseOnto(repo, "master")
|
||||
|
Don't hard-code 1 here, the point of the version field is to increase it. Don't hard-code 1 here, the point of the version field is to increase it.
Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a `#define` or a constant that was used as default version number.
The test doesn't have great value though
The version it needs to return in the version that is specified by the libgit2 headers in the The version it needs to return in the version that is specified by the libgit2 headers in the `#define`. That's what the compiler is building and that's what it will use in order to figure out the size of the struct, which has to match what we're telling libgit2 we have.
Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think. Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think.
|
||||
rebase, err := performRebaseOnto(repo, "master")
|
||||
|
Don't hard-code 1 here, the point of the version field is to increase it. Don't hard-code 1 here, the point of the version field is to increase it.
Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a `#define` or a constant that was used as default version number.
The test doesn't have great value though
The version it needs to return in the version that is specified by the libgit2 headers in the The version it needs to return in the version that is specified by the libgit2 headers in the `#define`. That's what the compiler is building and that's what it will use in order to figure out the size of the struct, which has to match what we're telling libgit2 we have.
Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think. Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think.
|
||||
checkFatal(t, err)
|
||||
|
Don't hard-code 1 here, the point of the version field is to increase it. Don't hard-code 1 here, the point of the version field is to increase it.
Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a `#define` or a constant that was used as default version number.
The test doesn't have great value though
The version it needs to return in the version that is specified by the libgit2 headers in the The version it needs to return in the version that is specified by the libgit2 headers in the `#define`. That's what the compiler is building and that's what it will use in order to figure out the size of the struct, which has to match what we're telling libgit2 we have.
Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think. Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think.
|
||||
defer rebase.Free()
|
||||
|
Don't hard-code 1 here, the point of the version field is to increase it. Don't hard-code 1 here, the point of the version field is to increase it.
Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a `#define` or a constant that was used as default version number.
The test doesn't have great value though
The version it needs to return in the version that is specified by the libgit2 headers in the The version it needs to return in the version that is specified by the libgit2 headers in the `#define`. That's what the compiler is building and that's what it will use in order to figure out the size of the struct, which has to match what we're telling libgit2 we have.
Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think. Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think.
|
||||
|
||||
|
Don't hard-code 1 here, the point of the version field is to increase it. Don't hard-code 1 here, the point of the version field is to increase it.
Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a `#define` or a constant that was used as default version number.
The test doesn't have great value though
The version it needs to return in the version that is specified by the libgit2 headers in the The version it needs to return in the version that is specified by the libgit2 headers in the `#define`. That's what the compiler is building and that's what it will use in order to figure out the size of the struct, which has to match what we're telling libgit2 we have.
Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think. Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think.
|
||||
// Finish the rebase properly
|
||||
|
Don't hard-code 1 here, the point of the version field is to increase it. Don't hard-code 1 here, the point of the version field is to increase it.
Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a `#define` or a constant that was used as default version number.
The test doesn't have great value though
The version it needs to return in the version that is specified by the libgit2 headers in the The version it needs to return in the version that is specified by the libgit2 headers in the `#define`. That's what the compiler is building and that's what it will use in order to figure out the size of the struct, which has to match what we're telling libgit2 we have.
Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think. Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think.
|
||||
err = rebase.Finish()
|
||||
|
Don't hard-code 1 here, the point of the version field is to increase it. Don't hard-code 1 here, the point of the version field is to increase it.
Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a `#define` or a constant that was used as default version number.
The test doesn't have great value though
The version it needs to return in the version that is specified by the libgit2 headers in the The version it needs to return in the version that is specified by the libgit2 headers in the `#define`. That's what the compiler is building and that's what it will use in order to figure out the size of the struct, which has to match what we're telling libgit2 we have.
Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think. Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think.
|
||||
checkFatal(t, err)
|
||||
|
||||
// Check history is in correct order
|
||||
|
|
@ -84,51 +141,45 @@ func setupRepoForRebase(repo *Repository, masterCommit, branchName string) error
|
|||
|
Don't hard-code 1 here, the point of the version field is to increase it. Don't hard-code 1 here, the point of the version field is to increase it.
Don't hard-code 1 here, the point of the version field is to increase it. Don't hard-code 1 here, the point of the version field is to increase it.
Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a `#define` or a constant that was used as default version number.
The test doesn't have great value though
Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a `#define` or a constant that was used as default version number.
The test doesn't have great value though
The version it needs to return in the version that is specified by the libgit2 headers in the The version it needs to return in the version that is specified by the libgit2 headers in the `#define`. That's what the compiler is building and that's what it will use in order to figure out the size of the struct, which has to match what we're telling libgit2 we have.
The version it needs to return in the version that is specified by the libgit2 headers in the The version it needs to return in the version that is specified by the libgit2 headers in the `#define`. That's what the compiler is building and that's what it will use in order to figure out the size of the struct, which has to match what we're telling libgit2 we have.
Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think. Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think.
Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think. Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think.
|
||||
return nil
|
||||
}
|
||||
|
||||
func performRebaseOnto(repo *Repository, branch string) error {
|
||||
|
Don't hard-code 1 here, the point of the version field is to increase it. Don't hard-code 1 here, the point of the version field is to increase it.
Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a `#define` or a constant that was used as default version number.
The test doesn't have great value though
The version it needs to return in the version that is specified by the libgit2 headers in the The version it needs to return in the version that is specified by the libgit2 headers in the `#define`. That's what the compiler is building and that's what it will use in order to figure out the size of the struct, which has to match what we're telling libgit2 we have.
Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think. Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think.
|
||||
func performRebaseOnto(repo *Repository, branch string) (*Rebase, error) {
|
||||
|
Don't hard-code 1 here, the point of the version field is to increase it. Don't hard-code 1 here, the point of the version field is to increase it.
Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a `#define` or a constant that was used as default version number.
The test doesn't have great value though
The version it needs to return in the version that is specified by the libgit2 headers in the The version it needs to return in the version that is specified by the libgit2 headers in the `#define`. That's what the compiler is building and that's what it will use in order to figure out the size of the struct, which has to match what we're telling libgit2 we have.
Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think. Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think.
|
||||
master, err := repo.LookupBranch(branch, BranchLocal)
|
||||
if err != nil {
|
||||
return err
|
||||
|
Don't hard-code 1 here, the point of the version field is to increase it. Don't hard-code 1 here, the point of the version field is to increase it.
Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a `#define` or a constant that was used as default version number.
The test doesn't have great value though
The version it needs to return in the version that is specified by the libgit2 headers in the The version it needs to return in the version that is specified by the libgit2 headers in the `#define`. That's what the compiler is building and that's what it will use in order to figure out the size of the struct, which has to match what we're telling libgit2 we have.
Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think. Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think.
|
||||
return nil, err
|
||||
|
Don't hard-code 1 here, the point of the version field is to increase it. Don't hard-code 1 here, the point of the version field is to increase it.
Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a `#define` or a constant that was used as default version number.
The test doesn't have great value though
The version it needs to return in the version that is specified by the libgit2 headers in the The version it needs to return in the version that is specified by the libgit2 headers in the `#define`. That's what the compiler is building and that's what it will use in order to figure out the size of the struct, which has to match what we're telling libgit2 we have.
Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think. Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think.
|
||||
}
|
||||
defer master.Free()
|
||||
|
||||
onto, err := repo.AnnotatedCommitFromRef(master.Reference)
|
||||
if err != nil {
|
||||
return err
|
||||
|
Don't hard-code 1 here, the point of the version field is to increase it. Don't hard-code 1 here, the point of the version field is to increase it.
Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a `#define` or a constant that was used as default version number.
The test doesn't have great value though
The version it needs to return in the version that is specified by the libgit2 headers in the The version it needs to return in the version that is specified by the libgit2 headers in the `#define`. That's what the compiler is building and that's what it will use in order to figure out the size of the struct, which has to match what we're telling libgit2 we have.
Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think. Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think.
|
||||
return nil, err
|
||||
|
Don't hard-code 1 here, the point of the version field is to increase it. Don't hard-code 1 here, the point of the version field is to increase it.
Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a `#define` or a constant that was used as default version number.
The test doesn't have great value though
The version it needs to return in the version that is specified by the libgit2 headers in the The version it needs to return in the version that is specified by the libgit2 headers in the `#define`. That's what the compiler is building and that's what it will use in order to figure out the size of the struct, which has to match what we're telling libgit2 we have.
Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think. Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think.
|
||||
}
|
||||
defer onto.Free()
|
||||
|
||||
rebase, err := repo.RebaseInit(nil, nil, onto, nil)
|
||||
if err != nil {
|
||||
return err
|
||||
|
Don't hard-code 1 here, the point of the version field is to increase it. Don't hard-code 1 here, the point of the version field is to increase it.
Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a `#define` or a constant that was used as default version number.
The test doesn't have great value though
The version it needs to return in the version that is specified by the libgit2 headers in the The version it needs to return in the version that is specified by the libgit2 headers in the `#define`. That's what the compiler is building and that's what it will use in order to figure out the size of the struct, which has to match what we're telling libgit2 we have.
Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think. Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think.
|
||||
return nil, err
|
||||
|
Don't hard-code 1 here, the point of the version field is to increase it. Don't hard-code 1 here, the point of the version field is to increase it.
Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a `#define` or a constant that was used as default version number.
The test doesn't have great value though
The version it needs to return in the version that is specified by the libgit2 headers in the The version it needs to return in the version that is specified by the libgit2 headers in the `#define`. That's what the compiler is building and that's what it will use in order to figure out the size of the struct, which has to match what we're telling libgit2 we have.
Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think. Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think.
|
||||
}
|
||||
defer rebase.Free()
|
||||
|
Don't hard-code 1 here, the point of the version field is to increase it. Don't hard-code 1 here, the point of the version field is to increase it.
Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a `#define` or a constant that was used as default version number.
The test doesn't have great value though
The version it needs to return in the version that is specified by the libgit2 headers in the The version it needs to return in the version that is specified by the libgit2 headers in the `#define`. That's what the compiler is building and that's what it will use in order to figure out the size of the struct, which has to match what we're telling libgit2 we have.
Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think. Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think.
|
||||
|
||||
opCount := int(rebase.OperationCount())
|
||||
|
||||
for op := 0; op < opCount; op++ {
|
||||
operation, err := rebase.Next()
|
||||
if err != nil {
|
||||
return err
|
||||
|
Don't hard-code 1 here, the point of the version field is to increase it. Don't hard-code 1 here, the point of the version field is to increase it.
Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a `#define` or a constant that was used as default version number.
The test doesn't have great value though
The version it needs to return in the version that is specified by the libgit2 headers in the The version it needs to return in the version that is specified by the libgit2 headers in the `#define`. That's what the compiler is building and that's what it will use in order to figure out the size of the struct, which has to match what we're telling libgit2 we have.
Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think. Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think.
|
||||
return nil, err
|
||||
|
Don't hard-code 1 here, the point of the version field is to increase it. Don't hard-code 1 here, the point of the version field is to increase it.
Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a `#define` or a constant that was used as default version number.
The test doesn't have great value though
The version it needs to return in the version that is specified by the libgit2 headers in the The version it needs to return in the version that is specified by the libgit2 headers in the `#define`. That's what the compiler is building and that's what it will use in order to figure out the size of the struct, which has to match what we're telling libgit2 we have.
Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think. Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think.
|
||||
}
|
||||
|
||||
commit, err := repo.LookupCommit(operation.ID)
|
||||
if err != nil {
|
||||
return err
|
||||
|
Don't hard-code 1 here, the point of the version field is to increase it. Don't hard-code 1 here, the point of the version field is to increase it.
Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a `#define` or a constant that was used as default version number.
The test doesn't have great value though
The version it needs to return in the version that is specified by the libgit2 headers in the The version it needs to return in the version that is specified by the libgit2 headers in the `#define`. That's what the compiler is building and that's what it will use in order to figure out the size of the struct, which has to match what we're telling libgit2 we have.
Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think. Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think.
|
||||
return nil, err
|
||||
|
Don't hard-code 1 here, the point of the version field is to increase it. Don't hard-code 1 here, the point of the version field is to increase it.
Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a `#define` or a constant that was used as default version number.
The test doesn't have great value though
The version it needs to return in the version that is specified by the libgit2 headers in the The version it needs to return in the version that is specified by the libgit2 headers in the `#define`. That's what the compiler is building and that's what it will use in order to figure out the size of the struct, which has to match what we're telling libgit2 we have.
Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think. Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think.
|
||||
}
|
||||
defer commit.Free()
|
||||
|
||||
err = rebase.Commit(operation.ID, signature(), signature(), commit.Message())
|
||||
if err != nil {
|
||||
return err
|
||||
|
Don't hard-code 1 here, the point of the version field is to increase it. Don't hard-code 1 here, the point of the version field is to increase it.
Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a `#define` or a constant that was used as default version number.
The test doesn't have great value though
The version it needs to return in the version that is specified by the libgit2 headers in the The version it needs to return in the version that is specified by the libgit2 headers in the `#define`. That's what the compiler is building and that's what it will use in order to figure out the size of the struct, which has to match what we're telling libgit2 we have.
Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think. Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think.
|
||||
return nil, err
|
||||
|
Don't hard-code 1 here, the point of the version field is to increase it. Don't hard-code 1 here, the point of the version field is to increase it.
Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a `#define` or a constant that was used as default version number.
The test doesn't have great value though
The version it needs to return in the version that is specified by the libgit2 headers in the The version it needs to return in the version that is specified by the libgit2 headers in the `#define`. That's what the compiler is building and that's what it will use in order to figure out the size of the struct, which has to match what we're telling libgit2 we have.
Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think. Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think.
|
||||
}
|
||||
}
|
||||
|
||||
err = rebase.Finish()
|
||||
|
Don't hard-code 1 here, the point of the version field is to increase it. Don't hard-code 1 here, the point of the version field is to increase it.
Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a `#define` or a constant that was used as default version number.
The test doesn't have great value though
The version it needs to return in the version that is specified by the libgit2 headers in the The version it needs to return in the version that is specified by the libgit2 headers in the `#define`. That's what the compiler is building and that's what it will use in order to figure out the size of the struct, which has to match what we're telling libgit2 we have.
Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think. Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think.
|
||||
if err != nil {
|
||||
|
Don't hard-code 1 here, the point of the version field is to increase it. Don't hard-code 1 here, the point of the version field is to increase it.
Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a `#define` or a constant that was used as default version number.
The test doesn't have great value though
The version it needs to return in the version that is specified by the libgit2 headers in the The version it needs to return in the version that is specified by the libgit2 headers in the `#define`. That's what the compiler is building and that's what it will use in order to figure out the size of the struct, which has to match what we're telling libgit2 we have.
Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think. Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think.
|
||||
return err
|
||||
|
Don't hard-code 1 here, the point of the version field is to increase it. Don't hard-code 1 here, the point of the version field is to increase it.
Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a `#define` or a constant that was used as default version number.
The test doesn't have great value though
The version it needs to return in the version that is specified by the libgit2 headers in the The version it needs to return in the version that is specified by the libgit2 headers in the `#define`. That's what the compiler is building and that's what it will use in order to figure out the size of the struct, which has to match what we're telling libgit2 we have.
Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think. Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think.
|
||||
}
|
||||
|
Don't hard-code 1 here, the point of the version field is to increase it. Don't hard-code 1 here, the point of the version field is to increase it.
Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a `#define` or a constant that was used as default version number.
The test doesn't have great value though
The version it needs to return in the version that is specified by the libgit2 headers in the The version it needs to return in the version that is specified by the libgit2 headers in the `#define`. That's what the compiler is building and that's what it will use in order to figure out the size of the struct, which has to match what we're telling libgit2 we have.
Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think. Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think.
|
||||
|
||||
|
Don't hard-code 1 here, the point of the version field is to increase it. Don't hard-code 1 here, the point of the version field is to increase it.
Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a `#define` or a constant that was used as default version number.
The test doesn't have great value though
The version it needs to return in the version that is specified by the libgit2 headers in the The version it needs to return in the version that is specified by the libgit2 headers in the `#define`. That's what the compiler is building and that's what it will use in order to figure out the size of the struct, which has to match what we're telling libgit2 we have.
Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think. Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think.
|
||||
return nil
|
||||
|
Don't hard-code 1 here, the point of the version field is to increase it. Don't hard-code 1 here, the point of the version field is to increase it.
Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a `#define` or a constant that was used as default version number.
The test doesn't have great value though
The version it needs to return in the version that is specified by the libgit2 headers in the The version it needs to return in the version that is specified by the libgit2 headers in the `#define`. That's what the compiler is building and that's what it will use in order to figure out the size of the struct, which has to match what we're telling libgit2 we have.
Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think. Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think.
|
||||
return rebase, nil
|
||||
|
Don't hard-code 1 here, the point of the version field is to increase it. Don't hard-code 1 here, the point of the version field is to increase it.
Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a `#define` or a constant that was used as default version number.
The test doesn't have great value though
The version it needs to return in the version that is specified by the libgit2 headers in the The version it needs to return in the version that is specified by the libgit2 headers in the `#define`. That's what the compiler is building and that's what it will use in order to figure out the size of the struct, which has to match what we're telling libgit2 we have.
Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think. Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think.
|
||||
}
|
||||
|
||||
func createBranch(repo *Repository, branch string) error {
|
||||
|
|
@ -225,7 +276,7 @@ func commitSomething(repo *Repository, something, content string) (*Oid, error)
|
|||
|
Don't hard-code 1 here, the point of the version field is to increase it. Don't hard-code 1 here, the point of the version field is to increase it.
Don't hard-code 1 here, the point of the version field is to increase it. Don't hard-code 1 here, the point of the version field is to increase it.
Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a `#define` or a constant that was used as default version number.
The test doesn't have great value though
Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a `#define` or a constant that was used as default version number.
The test doesn't have great value though
The version it needs to return in the version that is specified by the libgit2 headers in the The version it needs to return in the version that is specified by the libgit2 headers in the `#define`. That's what the compiler is building and that's what it will use in order to figure out the size of the struct, which has to match what we're telling libgit2 we have.
The version it needs to return in the version that is specified by the libgit2 headers in the The version it needs to return in the version that is specified by the libgit2 headers in the `#define`. That's what the compiler is building and that's what it will use in order to figure out the size of the struct, which has to match what we're telling libgit2 we have.
Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think. Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think.
Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think. Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think.
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
commit, err := repo.CreateCommit("HEAD", signature(), signature(), "Test rebase onto, Baby! "+something, newTree, headCommit)
|
||||
|
Don't hard-code 1 here, the point of the version field is to increase it. Don't hard-code 1 here, the point of the version field is to increase it.
Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a `#define` or a constant that was used as default version number.
The test doesn't have great value though
The version it needs to return in the version that is specified by the libgit2 headers in the The version it needs to return in the version that is specified by the libgit2 headers in the `#define`. That's what the compiler is building and that's what it will use in order to figure out the size of the struct, which has to match what we're telling libgit2 we have.
Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think. Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think.
|
||||
commit, err := repo.CreateCommit("HEAD", signature(), signature(), "Test rebase, Baby! "+something, newTree, headCommit)
|
||||
|
Don't hard-code 1 here, the point of the version field is to increase it. Don't hard-code 1 here, the point of the version field is to increase it.
Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a `#define` or a constant that was used as default version number.
The test doesn't have great value though
The version it needs to return in the version that is specified by the libgit2 headers in the The version it needs to return in the version that is specified by the libgit2 headers in the `#define`. That's what the compiler is building and that's what it will use in order to figure out the size of the struct, which has to match what we're telling libgit2 we have.
Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think. Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think.
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
|
|
|||
|
Don't hard-code 1 here, the point of the version field is to increase it. Don't hard-code 1 here, the point of the version field is to increase it.
Don't hard-code 1 here, the point of the version field is to increase it. Don't hard-code 1 here, the point of the version field is to increase it.
Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a `#define` or a constant that was used as default version number.
The test doesn't have great value though
Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a Not sure how to handle this. It's a test that checks the default version returned by DefaultRebaseOptions. After a look into C code, I thought it was a `#define` or a constant that was used as default version number.
The test doesn't have great value though
The version it needs to return in the version that is specified by the libgit2 headers in the The version it needs to return in the version that is specified by the libgit2 headers in the `#define`. That's what the compiler is building and that's what it will use in order to figure out the size of the struct, which has to match what we're telling libgit2 we have.
The version it needs to return in the version that is specified by the libgit2 headers in the The version it needs to return in the version that is specified by the libgit2 headers in the `#define`. That's what the compiler is building and that's what it will use in order to figure out the size of the struct, which has to match what we're telling libgit2 we have.
Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think. Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think.
Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think. Thanks for that. However I'm not sure how I should do as the cgo feature seems to be forbidden in tests... I will just drop this very low value test I think.
|
||||
This describes the structure mechanically, but almost everything is a wrapper, if we're going to have a comment here, it should describe the object itself and/or what you can do with it.
This describes the structure mechanically, but almost everything is a wrapper, if we're going to have a comment here, it should describe the object itself and/or what you can do with it.
We have prior art of naming
git_repository_init()asInitRepository()since the namespacing in C and Go is bit different, so this should be calledInitRebase().We have prior art of naming
git_repository_init()asInitRepository()since the namespacing in C and Go is bit different, so this should be calledInitRebase().Like with the init function, this should be called
OpenRebase(). The documentation shouldn't reference the C functiongit_rebase_initbut our own.Like with the init function, this should be called
OpenRebase(). The documentation shouldn't reference the C functiongit_rebase_initbut our own.This return value does not match how Go reports errors. I would expect a
uintto return the current operation and anerrorto return any errors.This return value does not match how Go reports errors. I would expect a
uintto return the current operation and anerrorto return any errors.There is no
GIT_REBASE_OPERATION_EXECin git2go, it'sRebaseOperationExec.There is no
GIT_REBASE_OPERATION_EXECin git2go, it'sRebaseOperationExec.There is no
git_rebase_nextin git2go, we haveNext().There is no
git_rebase_nextin git2go, we haveNext().Missing space. The pointer isn't public so let's not mention it. "unmanaged resources" covers whatever we decide to put in there.
Missing space. The pointer isn't public so let's not mention it. "unmanaged resources" covers whatever we decide to put in there.
The other public id fields are named
Id.The other public id fields are named
Id.Ok, I followed go convention suggested by my IDE plugin
Ok, I followed go convention suggested by my IDE plugin
Done
Done
Done
Done
Done
Done
Done.
I also added
ErrClassRebaseingit.goHope this is correct
Done.
I also added
ErrClassRebaseingit.goHope this is correct
Done
Done
Done
Done